dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11
  12 #ifndef SWIGCSHARP
  13 #define SWIGCSHARP
  14 #endif
  15
  16 #define SWIG_DIRECTORS
  17
  18
  19 #ifdef __cplusplus
  20 /* SwigValueWrapper is described in swig.swg */
  21 template<typename T> class SwigValueWrapper {
  22   struct SwigMovePointer {
  23     T *ptr;
  24     SwigMovePointer(T *p) : ptr(p) { }
  25     ~SwigMovePointer() { delete ptr; }
  26     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  27   } pointer;
  28   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  29   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  30 public:
  31   SwigValueWrapper() : pointer(0) { }
  32   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  33   operator T&() const { return *pointer.ptr; }
  34   T *operator&() { return pointer.ptr; }
  35 };
  36
  37 template <typename T> T SwigValueInit() {
  38   return T();
  39 }
  40 #endif
  41
  42 /* -----------------------------------------------------------------------------
  43  *  This section contains generic SWIG labels for method/variable
  44  *  declarations/attributes, and other compiler dependent labels.
  45  * ----------------------------------------------------------------------------- */
  46
  47 /* template workaround for compilers that cannot correctly implement the C++ standard */
  48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  50 #  define SWIGTEMPLATEDISAMBIGUATOR template
  51 # elif defined(__HP_aCC)
  52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  54 #  define SWIGTEMPLATEDISAMBIGUATOR template
  55 # else
  56 #  define SWIGTEMPLATEDISAMBIGUATOR
  57 # endif
  58 #endif
  59
  60 /* inline attribute */
  61 #ifndef SWIGINLINE
  62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  63 #   define SWIGINLINE inline
  64 # else
  65 #   define SWIGINLINE
  66 # endif
  67 #endif
  68
  69 /* attribute recognised by some compilers to avoid 'unused' warnings */
  70 #ifndef SWIGUNUSED
  71 # if defined(__GNUC__)
  72 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  73 #     define SWIGUNUSED __attribute__ ((__unused__))
  74 #   else
  75 #     define SWIGUNUSED
  76 #   endif
  77 # elif defined(__ICC)
  78 #   define SWIGUNUSED __attribute__ ((__unused__))
  79 # else
  80 #   define SWIGUNUSED
  81 # endif
  82 #endif
  83
  84 #ifndef SWIG_MSC_UNSUPPRESS_4505
  85 # if defined(_MSC_VER)
  86 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  87 # endif
  88 #endif
  89
  90 #ifndef SWIGUNUSEDPARM
  91 # ifdef __cplusplus
  92 #   define SWIGUNUSEDPARM(p)
  93 # else
  94 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  95 # endif
  96 #endif
  97
  98 /* internal SWIG method */
  99 #ifndef SWIGINTERN
 100 # define SWIGINTERN static SWIGUNUSED
 101 #endif
 102
 103 /* internal inline SWIG method */
 104 #ifndef SWIGINTERNINLINE
 105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 106 #endif
 107
 108 /* exporting methods */
 109 #if defined(__GNUC__)
 110 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 111 #    ifndef GCC_HASCLASSVISIBILITY
 112 #      define GCC_HASCLASSVISIBILITY
 113 #    endif
 114 #  endif
 115 #endif
 116
 117 #ifndef SWIGEXPORT
 118 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 119 #   if defined(STATIC_LINKED)
 120 #     define SWIGEXPORT
 121 #   else
 122 #     define SWIGEXPORT __declspec(dllexport)
 123 #   endif
 124 # else
 125 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 126 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 127 #   else
 128 #     define SWIGEXPORT
 129 #   endif
 130 # endif
 131 #endif
 132
 133 /* calling conventions for Windows */
 134 #ifndef SWIGSTDCALL
 135 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 136 #   define SWIGSTDCALL __stdcall
 137 # else
 138 #   define SWIGSTDCALL
 139 # endif
 140 #endif
 141
 142 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 143 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 144 # define _CRT_SECURE_NO_DEPRECATE
 145 #endif
 146
 147 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 148 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 149 # define _SCL_SECURE_NO_DEPRECATE
 150 #endif
 151
 152 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 153 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 154 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 155 #endif
 156
 157 /* Intel's compiler complains if a variable which was never initialised is
 158  * cast to void, which is a common idiom which we use to indicate that we
 159  * are aware a variable isn't used.  So we just silence that warning.
 160  * See: https://github.com/swig/swig/issues/192 for more discussion.
 161  */
 162 #ifdef __INTEL_COMPILER
 163 # pragma warning disable 592
 164 #endif
 165
 166
 167 #include <stdlib.h>
 168 #include <string.h>
 169 #include <stdio.h>
 170
 171
 172 /* Support for throwing C# exceptions from C/C++. There are two types:
 173  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 174 typedef enum {
 175   SWIG_CSharpApplicationException,
 176   SWIG_CSharpArithmeticException,
 177   SWIG_CSharpDivideByZeroException,
 178   SWIG_CSharpIndexOutOfRangeException,
 179   SWIG_CSharpInvalidCastException,
 180   SWIG_CSharpInvalidOperationException,
 181   SWIG_CSharpIOException,
 182   SWIG_CSharpNullReferenceException,
 183   SWIG_CSharpOutOfMemoryException,
 184   SWIG_CSharpOverflowException,
 185   SWIG_CSharpSystemException
 186 } SWIG_CSharpExceptionCodes;
 187
 188 typedef enum {
 189   SWIG_CSharpArgumentException,
 190   SWIG_CSharpArgumentNullException,
 191   SWIG_CSharpArgumentOutOfRangeException
 192 } SWIG_CSharpExceptionArgumentCodes;
 193
 194 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 195 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 196
 197 typedef struct {
 198   SWIG_CSharpExceptionCodes code;
 199   SWIG_CSharpExceptionCallback_t callback;
 200 } SWIG_CSharpException_t;
 201
 202 typedef struct {
 203   SWIG_CSharpExceptionArgumentCodes code;
 204   SWIG_CSharpExceptionArgumentCallback_t callback;
 205 } SWIG_CSharpExceptionArgument_t;
 206
 207 static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 208   { SWIG_CSharpApplicationException, NULL },
 209   { SWIG_CSharpArithmeticException, NULL },
 210   { SWIG_CSharpDivideByZeroException, NULL },
 211   { SWIG_CSharpIndexOutOfRangeException, NULL },
 212   { SWIG_CSharpInvalidCastException, NULL },
 213   { SWIG_CSharpInvalidOperationException, NULL },
 214   { SWIG_CSharpIOException, NULL },
 215   { SWIG_CSharpNullReferenceException, NULL },
 216   { SWIG_CSharpOutOfMemoryException, NULL },
 217   { SWIG_CSharpOverflowException, NULL },
 218   { SWIG_CSharpSystemException, NULL }
 219 };
 220
 221 static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 222   { SWIG_CSharpArgumentException, NULL },
 223   { SWIG_CSharpArgumentNullException, NULL },
 224   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 225 };
 226
 227 static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 228   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 229   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 230     callback = SWIG_csharp_exceptions[code].callback;
 231   }
 232   callback(msg);
 233 }
 234
 235 static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 236   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 237   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 238     callback = SWIG_csharp_exceptions_argument[code].callback;
 239   }
 240   callback(msg, param_name);
 241 }
 242
 243
 244 #ifdef __cplusplus
 245 extern "C"
 246 #endif
 247 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 248                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 249                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 250                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 251                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 252                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 253                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 254                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 255                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 256                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 257                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 258                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 259   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 267   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 268   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 269   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 270 }
 271
 272 #ifdef __cplusplus
 273 extern "C"
 274 #endif
 275 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 276                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 277                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 278                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 279   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 280   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 281   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 282 }
 283
 284
 285 /* Callback for returning strings to C# without leaking memory */
 286 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 287 static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 288
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425 #include <dali/devel-api/events/key-event-devel.h>
 426
 427 #include <dali/devel-api/actors/actor-devel.h>
 428
 429 #include <dali/public-api/math/matrix.h>
 430 #include <dali/public-api/math/matrix3.h>
 431 #include <dali/public-api/math/viewport.h>
 432 #include <dali/public-api/object/property-key.h>
 433 #include <dali/devel-api/object/csharp-type-info.h>
 434 #include <dali/devel-api/object/csharp-type-registry.h>
 435
 436 #include <dali/public-api/adaptor-framework/timer.h>
 437 #include <dali/public-api/adaptor-framework/window.h>
 438 #include <dali/public-api/adaptor-framework/style-change.h>
 439 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 440 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 441 #include <dali/devel-api/adaptor-framework/window-devel.h>
 442
 443 #include <dali/devel-api/images/nine-patch-image.h>
 444
 445 #include <dali-toolkit/devel-api/builder/builder.h>
 446
 447 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 448 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 449
 450 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 451 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 452 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 456 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.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 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
27283   void * jresult ;
27284   Dali::KeyEvent *arg1 = 0 ;
27285   Dali::KeyEvent *result = 0 ;
27286
27287   arg1 = (Dali::KeyEvent *)jarg1;
27288   if (!arg1) {
27289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27290     return 0;
27291   }
27292   {
27293     try {
27294       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
27295     } catch (std::out_of_range& e) {
27296       {
27297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27298       };
27299     } catch (std::exception& e) {
27300       {
27301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27302       };
27303     } catch (...) {
27304       {
27305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27306       };
27307     }
27308   }
27309   jresult = (void *)result;
27310   return jresult;
27311 }
27312
27313
27314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
27315   void * jresult ;
27316   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27317   Dali::KeyEvent *arg2 = 0 ;
27318   Dali::KeyEvent *result = 0 ;
27319
27320   arg1 = (Dali::KeyEvent *)jarg1;
27321   arg2 = (Dali::KeyEvent *)jarg2;
27322   if (!arg2) {
27323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27324     return 0;
27325   }
27326   {
27327     try {
27328       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
27329     } catch (std::out_of_range& e) {
27330       {
27331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27332       };
27333     } catch (std::exception& e) {
27334       {
27335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27336       };
27337     } catch (...) {
27338       {
27339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27340       };
27341     }
27342   }
27343   jresult = (void *)result;
27344   return jresult;
27345 }
27346
27347
27348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27349   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27350
27351   arg1 = (Dali::KeyEvent *)jarg1;
27352   {
27353     try {
27354       delete arg1;
27355     } catch (std::out_of_range& e) {
27356       {
27357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27358       };
27359     } catch (std::exception& e) {
27360       {
27361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27362       };
27363     } catch (...) {
27364       {
27365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27366       };
27367     }
27368   }
27369 }
27370
27371
27372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27373   unsigned int jresult ;
27374   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27375   bool result;
27376
27377   arg1 = (Dali::KeyEvent *)jarg1;
27378   {
27379     try {
27380       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27381     } catch (std::out_of_range& e) {
27382       {
27383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27384       };
27385     } catch (std::exception& e) {
27386       {
27387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27388       };
27389     } catch (...) {
27390       {
27391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27392       };
27393     }
27394   }
27395   jresult = result;
27396   return jresult;
27397 }
27398
27399
27400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27401   unsigned int jresult ;
27402   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27403   bool result;
27404
27405   arg1 = (Dali::KeyEvent *)jarg1;
27406   {
27407     try {
27408       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27409     } catch (std::out_of_range& e) {
27410       {
27411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27412       };
27413     } catch (std::exception& e) {
27414       {
27415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27416       };
27417     } catch (...) {
27418       {
27419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27420       };
27421     }
27422   }
27423   jresult = result;
27424   return jresult;
27425 }
27426
27427
27428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27429   unsigned int jresult ;
27430   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27431   bool result;
27432
27433   arg1 = (Dali::KeyEvent *)jarg1;
27434   {
27435     try {
27436       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27437     } catch (std::out_of_range& e) {
27438       {
27439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27440       };
27441     } catch (std::exception& e) {
27442       {
27443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27444       };
27445     } catch (...) {
27446       {
27447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27448       };
27449     }
27450   }
27451   jresult = result;
27452   return jresult;
27453 }
27454
27455
27456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27457   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27458   std::string *arg2 = 0 ;
27459
27460   arg1 = (Dali::KeyEvent *)jarg1;
27461   if (!jarg2) {
27462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27463     return ;
27464   }
27465   std::string arg2_str(jarg2);
27466   arg2 = &arg2_str;
27467   if (arg1) (arg1)->keyPressedName = *arg2;
27468
27469   //argout typemap for const std::string&
27470
27471 }
27472
27473
27474 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27475   char * jresult ;
27476   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27477   std::string *result = 0 ;
27478
27479   arg1 = (Dali::KeyEvent *)jarg1;
27480   result = (std::string *) & ((arg1)->keyPressedName);
27481   jresult = SWIG_csharp_string_callback(result->c_str());
27482   return jresult;
27483 }
27484
27485
27486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27487   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27488   std::string *arg2 = 0 ;
27489
27490   arg1 = (Dali::KeyEvent *)jarg1;
27491   if (!jarg2) {
27492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27493     return ;
27494   }
27495   std::string arg2_str(jarg2);
27496   arg2 = &arg2_str;
27497   if (arg1) (arg1)->keyPressed = *arg2;
27498
27499   //argout typemap for const std::string&
27500
27501 }
27502
27503
27504 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27505   char * jresult ;
27506   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27507   std::string *result = 0 ;
27508
27509   arg1 = (Dali::KeyEvent *)jarg1;
27510   result = (std::string *) & ((arg1)->keyPressed);
27511   jresult = SWIG_csharp_string_callback(result->c_str());
27512   return jresult;
27513 }
27514
27515
27516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27517   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27518   int arg2 ;
27519
27520   arg1 = (Dali::KeyEvent *)jarg1;
27521   arg2 = (int)jarg2;
27522   if (arg1) (arg1)->keyCode = arg2;
27523 }
27524
27525
27526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27527   int jresult ;
27528   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27529   int result;
27530
27531   arg1 = (Dali::KeyEvent *)jarg1;
27532   result = (int) ((arg1)->keyCode);
27533   jresult = result;
27534   return jresult;
27535 }
27536
27537
27538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27539   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27540   int arg2 ;
27541
27542   arg1 = (Dali::KeyEvent *)jarg1;
27543   arg2 = (int)jarg2;
27544   if (arg1) (arg1)->keyModifier = arg2;
27545 }
27546
27547
27548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27549   int jresult ;
27550   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27551   int result;
27552
27553   arg1 = (Dali::KeyEvent *)jarg1;
27554   result = (int) ((arg1)->keyModifier);
27555   jresult = result;
27556   return jresult;
27557 }
27558
27559
27560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27561   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27562   unsigned long arg2 ;
27563
27564   arg1 = (Dali::KeyEvent *)jarg1;
27565   arg2 = (unsigned long)jarg2;
27566   if (arg1) (arg1)->time = arg2;
27567 }
27568
27569
27570 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27571   unsigned long jresult ;
27572   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27573   unsigned long result;
27574
27575   arg1 = (Dali::KeyEvent *)jarg1;
27576   result = (unsigned long) ((arg1)->time);
27577   jresult = (unsigned long)result;
27578   return jresult;
27579 }
27580
27581
27582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27583   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27584   Dali::KeyEvent::State arg2 ;
27585
27586   arg1 = (Dali::KeyEvent *)jarg1;
27587   arg2 = (Dali::KeyEvent::State)jarg2;
27588   if (arg1) (arg1)->state = arg2;
27589 }
27590
27591
27592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27593   int jresult ;
27594   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27595   Dali::KeyEvent::State result;
27596
27597   arg1 = (Dali::KeyEvent *)jarg1;
27598   result = (Dali::KeyEvent::State) ((arg1)->state);
27599   jresult = (int)result;
27600   return jresult;
27601 }
27602
27603
27604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27605   void * jresult ;
27606   Dali::LongPressGestureDetector *result = 0 ;
27607
27608   {
27609     try {
27610       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27611     } catch (std::out_of_range& e) {
27612       {
27613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27614       };
27615     } catch (std::exception& e) {
27616       {
27617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27618       };
27619     } catch (...) {
27620       {
27621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27622       };
27623     }
27624   }
27625   jresult = (void *)result;
27626   return jresult;
27627 }
27628
27629
27630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27631   void * jresult ;
27632   Dali::LongPressGestureDetector result;
27633
27634   {
27635     try {
27636       result = Dali::LongPressGestureDetector::New();
27637     } catch (std::out_of_range& e) {
27638       {
27639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27640       };
27641     } catch (std::exception& e) {
27642       {
27643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27644       };
27645     } catch (...) {
27646       {
27647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27648       };
27649     }
27650   }
27651   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27652   return jresult;
27653 }
27654
27655
27656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27657   void * jresult ;
27658   unsigned int arg1 ;
27659   Dali::LongPressGestureDetector result;
27660
27661   arg1 = (unsigned int)jarg1;
27662   {
27663     try {
27664       result = Dali::LongPressGestureDetector::New(arg1);
27665     } catch (std::out_of_range& e) {
27666       {
27667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27668       };
27669     } catch (std::exception& e) {
27670       {
27671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27672       };
27673     } catch (...) {
27674       {
27675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27676       };
27677     }
27678   }
27679   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27680   return jresult;
27681 }
27682
27683
27684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27685   void * jresult ;
27686   unsigned int arg1 ;
27687   unsigned int arg2 ;
27688   Dali::LongPressGestureDetector result;
27689
27690   arg1 = (unsigned int)jarg1;
27691   arg2 = (unsigned int)jarg2;
27692   {
27693     try {
27694       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27695     } catch (std::out_of_range& e) {
27696       {
27697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27698       };
27699     } catch (std::exception& e) {
27700       {
27701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27702       };
27703     } catch (...) {
27704       {
27705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27706       };
27707     }
27708   }
27709   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27710   return jresult;
27711 }
27712
27713
27714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27715   void * jresult ;
27716   Dali::BaseHandle arg1 ;
27717   Dali::BaseHandle *argp1 ;
27718   Dali::LongPressGestureDetector result;
27719
27720   argp1 = (Dali::BaseHandle *)jarg1;
27721   if (!argp1) {
27722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27723     return 0;
27724   }
27725   arg1 = *argp1;
27726   {
27727     try {
27728       result = Dali::LongPressGestureDetector::DownCast(arg1);
27729     } catch (std::out_of_range& e) {
27730       {
27731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27732       };
27733     } catch (std::exception& e) {
27734       {
27735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27736       };
27737     } catch (...) {
27738       {
27739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27740       };
27741     }
27742   }
27743   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27744   return jresult;
27745 }
27746
27747
27748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27749   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27750
27751   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27752   {
27753     try {
27754       delete arg1;
27755     } catch (std::out_of_range& e) {
27756       {
27757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27758       };
27759     } catch (std::exception& e) {
27760       {
27761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27762       };
27763     } catch (...) {
27764       {
27765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27766       };
27767     }
27768   }
27769 }
27770
27771
27772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27773   void * jresult ;
27774   Dali::LongPressGestureDetector *arg1 = 0 ;
27775   Dali::LongPressGestureDetector *result = 0 ;
27776
27777   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27778   if (!arg1) {
27779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27780     return 0;
27781   }
27782   {
27783     try {
27784       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27785     } catch (std::out_of_range& e) {
27786       {
27787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27788       };
27789     } catch (std::exception& e) {
27790       {
27791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27792       };
27793     } catch (...) {
27794       {
27795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27796       };
27797     }
27798   }
27799   jresult = (void *)result;
27800   return jresult;
27801 }
27802
27803
27804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27805   void * jresult ;
27806   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27807   Dali::LongPressGestureDetector *arg2 = 0 ;
27808   Dali::LongPressGestureDetector *result = 0 ;
27809
27810   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27811   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27812   if (!arg2) {
27813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27814     return 0;
27815   }
27816   {
27817     try {
27818       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27819     } catch (std::out_of_range& e) {
27820       {
27821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27822       };
27823     } catch (std::exception& e) {
27824       {
27825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27826       };
27827     } catch (...) {
27828       {
27829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27830       };
27831     }
27832   }
27833   jresult = (void *)result;
27834   return jresult;
27835 }
27836
27837
27838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27839   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27840   unsigned int arg2 ;
27841
27842   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27843   arg2 = (unsigned int)jarg2;
27844   {
27845     try {
27846       (arg1)->SetTouchesRequired(arg2);
27847     } catch (std::out_of_range& e) {
27848       {
27849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27850       };
27851     } catch (std::exception& e) {
27852       {
27853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27854       };
27855     } catch (...) {
27856       {
27857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27858       };
27859     }
27860   }
27861 }
27862
27863
27864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27865   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27866   unsigned int arg2 ;
27867   unsigned int arg3 ;
27868
27869   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27870   arg2 = (unsigned int)jarg2;
27871   arg3 = (unsigned int)jarg3;
27872   {
27873     try {
27874       (arg1)->SetTouchesRequired(arg2,arg3);
27875     } catch (std::out_of_range& e) {
27876       {
27877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27878       };
27879     } catch (std::exception& e) {
27880       {
27881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27882       };
27883     } catch (...) {
27884       {
27885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27886       };
27887     }
27888   }
27889 }
27890
27891
27892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27893   unsigned int jresult ;
27894   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27895   unsigned int result;
27896
27897   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27898   {
27899     try {
27900       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27901     } catch (std::out_of_range& e) {
27902       {
27903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27904       };
27905     } catch (std::exception& e) {
27906       {
27907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27908       };
27909     } catch (...) {
27910       {
27911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27912       };
27913     }
27914   }
27915   jresult = result;
27916   return jresult;
27917 }
27918
27919
27920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27921   unsigned int jresult ;
27922   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27923   unsigned int result;
27924
27925   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27926   {
27927     try {
27928       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27929     } catch (std::out_of_range& e) {
27930       {
27931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27932       };
27933     } catch (std::exception& e) {
27934       {
27935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27936       };
27937     } catch (...) {
27938       {
27939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27940       };
27941     }
27942   }
27943   jresult = result;
27944   return jresult;
27945 }
27946
27947
27948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27949   void * jresult ;
27950   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27951   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27952
27953   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27954   {
27955     try {
27956       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27957     } catch (std::out_of_range& e) {
27958       {
27959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27960       };
27961     } catch (std::exception& e) {
27962       {
27963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27964       };
27965     } catch (...) {
27966       {
27967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27968       };
27969     }
27970   }
27971   jresult = (void *)result;
27972   return jresult;
27973 }
27974
27975
27976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27977   void * jresult ;
27978   Dali::Gesture::State arg1 ;
27979   Dali::LongPressGesture *result = 0 ;
27980
27981   arg1 = (Dali::Gesture::State)jarg1;
27982   {
27983     try {
27984       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27985     } catch (std::out_of_range& e) {
27986       {
27987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27988       };
27989     } catch (std::exception& e) {
27990       {
27991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27992       };
27993     } catch (...) {
27994       {
27995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27996       };
27997     }
27998   }
27999   jresult = (void *)result;
28000   return jresult;
28001 }
28002
28003
28004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
28005   void * jresult ;
28006   Dali::LongPressGesture *arg1 = 0 ;
28007   Dali::LongPressGesture *result = 0 ;
28008
28009   arg1 = (Dali::LongPressGesture *)jarg1;
28010   if (!arg1) {
28011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
28012     return 0;
28013   }
28014   {
28015     try {
28016       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
28017     } catch (std::out_of_range& e) {
28018       {
28019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28020       };
28021     } catch (std::exception& e) {
28022       {
28023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28024       };
28025     } catch (...) {
28026       {
28027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28028       };
28029     }
28030   }
28031   jresult = (void *)result;
28032   return jresult;
28033 }
28034
28035
28036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
28037   void * jresult ;
28038   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28039   Dali::LongPressGesture *arg2 = 0 ;
28040   Dali::LongPressGesture *result = 0 ;
28041
28042   arg1 = (Dali::LongPressGesture *)jarg1;
28043   arg2 = (Dali::LongPressGesture *)jarg2;
28044   if (!arg2) {
28045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
28046     return 0;
28047   }
28048   {
28049     try {
28050       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
28051     } catch (std::out_of_range& e) {
28052       {
28053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28054       };
28055     } catch (std::exception& e) {
28056       {
28057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28058       };
28059     } catch (...) {
28060       {
28061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28062       };
28063     }
28064   }
28065   jresult = (void *)result;
28066   return jresult;
28067 }
28068
28069
28070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
28071   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28072
28073   arg1 = (Dali::LongPressGesture *)jarg1;
28074   {
28075     try {
28076       delete arg1;
28077     } catch (std::out_of_range& e) {
28078       {
28079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28080       };
28081     } catch (std::exception& e) {
28082       {
28083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28084       };
28085     } catch (...) {
28086       {
28087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28088       };
28089     }
28090   }
28091 }
28092
28093
28094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28095   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28096   unsigned int arg2 ;
28097
28098   arg1 = (Dali::LongPressGesture *)jarg1;
28099   arg2 = (unsigned int)jarg2;
28100   if (arg1) (arg1)->numberOfTouches = arg2;
28101 }
28102
28103
28104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28105   unsigned int jresult ;
28106   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28107   unsigned int result;
28108
28109   arg1 = (Dali::LongPressGesture *)jarg1;
28110   result = (unsigned int) ((arg1)->numberOfTouches);
28111   jresult = result;
28112   return jresult;
28113 }
28114
28115
28116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28117   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28118   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28119
28120   arg1 = (Dali::LongPressGesture *)jarg1;
28121   arg2 = (Dali::Vector2 *)jarg2;
28122   if (arg1) (arg1)->screenPoint = *arg2;
28123 }
28124
28125
28126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28127   void * jresult ;
28128   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28129   Dali::Vector2 *result = 0 ;
28130
28131   arg1 = (Dali::LongPressGesture *)jarg1;
28132   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28133   jresult = (void *)result;
28134   return jresult;
28135 }
28136
28137
28138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28139   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28140   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28141
28142   arg1 = (Dali::LongPressGesture *)jarg1;
28143   arg2 = (Dali::Vector2 *)jarg2;
28144   if (arg1) (arg1)->localPoint = *arg2;
28145 }
28146
28147
28148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28149   void * jresult ;
28150   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28151   Dali::Vector2 *result = 0 ;
28152
28153   arg1 = (Dali::LongPressGesture *)jarg1;
28154   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28155   jresult = (void *)result;
28156   return jresult;
28157 }
28158
28159
28160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28161   void * jresult ;
28162   Dali::WheelEvent *result = 0 ;
28163
28164   {
28165     try {
28166       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28167     } catch (std::out_of_range& e) {
28168       {
28169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28170       };
28171     } catch (std::exception& e) {
28172       {
28173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28174       };
28175     } catch (...) {
28176       {
28177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28178       };
28179     }
28180   }
28181   jresult = (void *)result;
28182   return jresult;
28183 }
28184
28185
28186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28187   void * jresult ;
28188   Dali::WheelEvent::Type arg1 ;
28189   int arg2 ;
28190   unsigned int arg3 ;
28191   Dali::Vector2 arg4 ;
28192   int arg5 ;
28193   unsigned int arg6 ;
28194   Dali::Vector2 *argp4 ;
28195   Dali::WheelEvent *result = 0 ;
28196
28197   arg1 = (Dali::WheelEvent::Type)jarg1;
28198   arg2 = (int)jarg2;
28199   arg3 = (unsigned int)jarg3;
28200   argp4 = (Dali::Vector2 *)jarg4;
28201   if (!argp4) {
28202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28203     return 0;
28204   }
28205   arg4 = *argp4;
28206   arg5 = (int)jarg5;
28207   arg6 = (unsigned int)jarg6;
28208   {
28209     try {
28210       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28211     } catch (std::out_of_range& e) {
28212       {
28213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28214       };
28215     } catch (std::exception& e) {
28216       {
28217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28218       };
28219     } catch (...) {
28220       {
28221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28222       };
28223     }
28224   }
28225   jresult = (void *)result;
28226   return jresult;
28227 }
28228
28229
28230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28231   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28232
28233   arg1 = (Dali::WheelEvent *)jarg1;
28234   {
28235     try {
28236       delete arg1;
28237     } catch (std::out_of_range& e) {
28238       {
28239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28240       };
28241     } catch (std::exception& e) {
28242       {
28243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28244       };
28245     } catch (...) {
28246       {
28247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28248       };
28249     }
28250   }
28251 }
28252
28253
28254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28255   unsigned int jresult ;
28256   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28257   bool result;
28258
28259   arg1 = (Dali::WheelEvent *)jarg1;
28260   {
28261     try {
28262       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28263     } catch (std::out_of_range& e) {
28264       {
28265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28266       };
28267     } catch (std::exception& e) {
28268       {
28269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28270       };
28271     } catch (...) {
28272       {
28273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28274       };
28275     }
28276   }
28277   jresult = result;
28278   return jresult;
28279 }
28280
28281
28282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28283   unsigned int jresult ;
28284   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28285   bool result;
28286
28287   arg1 = (Dali::WheelEvent *)jarg1;
28288   {
28289     try {
28290       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28291     } catch (std::out_of_range& e) {
28292       {
28293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28294       };
28295     } catch (std::exception& e) {
28296       {
28297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28298       };
28299     } catch (...) {
28300       {
28301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28302       };
28303     }
28304   }
28305   jresult = result;
28306   return jresult;
28307 }
28308
28309
28310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28311   unsigned int jresult ;
28312   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28313   bool result;
28314
28315   arg1 = (Dali::WheelEvent *)jarg1;
28316   {
28317     try {
28318       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28319     } catch (std::out_of_range& e) {
28320       {
28321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28322       };
28323     } catch (std::exception& e) {
28324       {
28325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28326       };
28327     } catch (...) {
28328       {
28329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28330       };
28331     }
28332   }
28333   jresult = result;
28334   return jresult;
28335 }
28336
28337
28338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28339   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28340   Dali::WheelEvent::Type arg2 ;
28341
28342   arg1 = (Dali::WheelEvent *)jarg1;
28343   arg2 = (Dali::WheelEvent::Type)jarg2;
28344   if (arg1) (arg1)->type = arg2;
28345 }
28346
28347
28348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28349   int jresult ;
28350   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28351   Dali::WheelEvent::Type result;
28352
28353   arg1 = (Dali::WheelEvent *)jarg1;
28354   result = (Dali::WheelEvent::Type) ((arg1)->type);
28355   jresult = (int)result;
28356   return jresult;
28357 }
28358
28359
28360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28361   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28362   int arg2 ;
28363
28364   arg1 = (Dali::WheelEvent *)jarg1;
28365   arg2 = (int)jarg2;
28366   if (arg1) (arg1)->direction = arg2;
28367 }
28368
28369
28370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28371   int jresult ;
28372   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28373   int result;
28374
28375   arg1 = (Dali::WheelEvent *)jarg1;
28376   result = (int) ((arg1)->direction);
28377   jresult = result;
28378   return jresult;
28379 }
28380
28381
28382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28383   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28384   unsigned int arg2 ;
28385
28386   arg1 = (Dali::WheelEvent *)jarg1;
28387   arg2 = (unsigned int)jarg2;
28388   if (arg1) (arg1)->modifiers = arg2;
28389 }
28390
28391
28392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28393   unsigned int jresult ;
28394   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28395   unsigned int result;
28396
28397   arg1 = (Dali::WheelEvent *)jarg1;
28398   result = (unsigned int) ((arg1)->modifiers);
28399   jresult = result;
28400   return jresult;
28401 }
28402
28403
28404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28405   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28406   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28407
28408   arg1 = (Dali::WheelEvent *)jarg1;
28409   arg2 = (Dali::Vector2 *)jarg2;
28410   if (arg1) (arg1)->point = *arg2;
28411 }
28412
28413
28414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28415   void * jresult ;
28416   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28417   Dali::Vector2 *result = 0 ;
28418
28419   arg1 = (Dali::WheelEvent *)jarg1;
28420   result = (Dali::Vector2 *)& ((arg1)->point);
28421   jresult = (void *)result;
28422   return jresult;
28423 }
28424
28425
28426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28427   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28428   int arg2 ;
28429
28430   arg1 = (Dali::WheelEvent *)jarg1;
28431   arg2 = (int)jarg2;
28432   if (arg1) (arg1)->z = arg2;
28433 }
28434
28435
28436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28437   int jresult ;
28438   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28439   int result;
28440
28441   arg1 = (Dali::WheelEvent *)jarg1;
28442   result = (int) ((arg1)->z);
28443   jresult = result;
28444   return jresult;
28445 }
28446
28447
28448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28449   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28450   unsigned int arg2 ;
28451
28452   arg1 = (Dali::WheelEvent *)jarg1;
28453   arg2 = (unsigned int)jarg2;
28454   if (arg1) (arg1)->timeStamp = arg2;
28455 }
28456
28457
28458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28459   unsigned int jresult ;
28460   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28461   unsigned int result;
28462
28463   arg1 = (Dali::WheelEvent *)jarg1;
28464   result = (unsigned int) ((arg1)->timeStamp);
28465   jresult = result;
28466   return jresult;
28467 }
28468
28469 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
28470   char * jresult ;
28471   Dali::KeyEvent *arg1 = 0 ;
28472   std::string result;
28473
28474   arg1 = (Dali::KeyEvent *)jarg1;
28475   if (!arg1) {
28476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28477     return 0;
28478   }
28479   {
28480     try {
28481       result = Dali::DevelKeyEvent::GetDeviceName((Dali::KeyEvent const &)*arg1);
28482     } catch (std::out_of_range& e) {
28483       {
28484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28485       };
28486     } catch (std::exception& e) {
28487       {
28488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28489       };
28490     } catch (...) {
28491       {
28492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28493       };
28494     }
28495   }
28496   jresult = SWIG_csharp_string_callback((&result)->c_str());
28497   return jresult;
28498 }
28499
28500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
28501   int jresult ;
28502   Dali::KeyEvent *arg1 = 0 ;
28503   Dali::DevelKeyEvent::DeviceClass::Type result;
28504
28505   arg1 = (Dali::KeyEvent *)jarg1;
28506   if (!arg1) {
28507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28508     return 0;
28509   }
28510   {
28511     try {
28512       result = (Dali::DevelKeyEvent::DeviceClass::Type)Dali::DevelKeyEvent::GetDeviceClass((Dali::KeyEvent const &)*arg1);
28513     } catch (std::out_of_range& e) {
28514       {
28515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28516       };
28517     } catch (std::exception& e) {
28518       {
28519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28520       };
28521     } catch (...) {
28522       {
28523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28524       };
28525     }
28526   }
28527   jresult = (int)result;
28528   return jresult;
28529 }
28530
28531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28532   int jresult ;
28533   int result;
28534
28535   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28536   jresult = (int)result;
28537   return jresult;
28538 }
28539
28540
28541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28542   int jresult ;
28543   int result;
28544
28545   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28546   jresult = (int)result;
28547   return jresult;
28548 }
28549
28550
28551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28552   int jresult ;
28553   int result;
28554
28555   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28556   jresult = (int)result;
28557   return jresult;
28558 }
28559
28560
28561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28562   int jresult ;
28563   int result;
28564
28565   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28566   jresult = (int)result;
28567   return jresult;
28568 }
28569
28570
28571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28572   int jresult ;
28573   int result;
28574
28575   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28576   jresult = (int)result;
28577   return jresult;
28578 }
28579
28580
28581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28582   int jresult ;
28583   int result;
28584
28585   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28586   jresult = (int)result;
28587   return jresult;
28588 }
28589
28590
28591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28592   int jresult ;
28593   int result;
28594
28595   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28596   jresult = (int)result;
28597   return jresult;
28598 }
28599
28600
28601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28602   int jresult ;
28603   int result;
28604
28605   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28606   jresult = (int)result;
28607   return jresult;
28608 }
28609
28610
28611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28612   int jresult ;
28613   int result;
28614
28615   result = (int)Dali::Actor::Property::SIZE;
28616   jresult = (int)result;
28617   return jresult;
28618 }
28619
28620
28621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28622   int jresult ;
28623   int result;
28624
28625   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28626   jresult = (int)result;
28627   return jresult;
28628 }
28629
28630
28631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28632   int jresult ;
28633   int result;
28634
28635   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28636   jresult = (int)result;
28637   return jresult;
28638 }
28639
28640
28641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28642   int jresult ;
28643   int result;
28644
28645   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28646   jresult = (int)result;
28647   return jresult;
28648 }
28649
28650
28651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28652   int jresult ;
28653   int result;
28654
28655   result = (int)Dali::Actor::Property::POSITION;
28656   jresult = (int)result;
28657   return jresult;
28658 }
28659
28660
28661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28662   int jresult ;
28663   int result;
28664
28665   result = (int)Dali::Actor::Property::POSITION_X;
28666   jresult = (int)result;
28667   return jresult;
28668 }
28669
28670
28671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28672   int jresult ;
28673   int result;
28674
28675   result = (int)Dali::Actor::Property::POSITION_Y;
28676   jresult = (int)result;
28677   return jresult;
28678 }
28679
28680
28681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28682   int jresult ;
28683   int result;
28684
28685   result = (int)Dali::Actor::Property::POSITION_Z;
28686   jresult = (int)result;
28687   return jresult;
28688 }
28689
28690
28691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28692   int jresult ;
28693   int result;
28694
28695   result = (int)Dali::Actor::Property::WORLD_POSITION;
28696   jresult = (int)result;
28697   return jresult;
28698 }
28699
28700
28701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28702   int jresult ;
28703   int result;
28704
28705   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28706   jresult = (int)result;
28707   return jresult;
28708 }
28709
28710
28711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28712   int jresult ;
28713   int result;
28714
28715   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28716   jresult = (int)result;
28717   return jresult;
28718 }
28719
28720
28721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28722   int jresult ;
28723   int result;
28724
28725   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28726   jresult = (int)result;
28727   return jresult;
28728 }
28729
28730
28731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28732   int jresult ;
28733   int result;
28734
28735   result = (int)Dali::Actor::Property::ORIENTATION;
28736   jresult = (int)result;
28737   return jresult;
28738 }
28739
28740
28741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28742   int jresult ;
28743   int result;
28744
28745   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28746   jresult = (int)result;
28747   return jresult;
28748 }
28749
28750
28751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
28752   int jresult ;
28753   int result;
28754
28755   result = (int)Dali::Actor::Property::SCALE;
28756   jresult = (int)result;
28757   return jresult;
28758 }
28759
28760
28761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
28762   int jresult ;
28763   int result;
28764
28765   result = (int)Dali::Actor::Property::SCALE_X;
28766   jresult = (int)result;
28767   return jresult;
28768 }
28769
28770
28771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
28772   int jresult ;
28773   int result;
28774
28775   result = (int)Dali::Actor::Property::SCALE_Y;
28776   jresult = (int)result;
28777   return jresult;
28778 }
28779
28780
28781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
28782   int jresult ;
28783   int result;
28784
28785   result = (int)Dali::Actor::Property::SCALE_Z;
28786   jresult = (int)result;
28787   return jresult;
28788 }
28789
28790
28791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
28792   int jresult ;
28793   int result;
28794
28795   result = (int)Dali::Actor::Property::WORLD_SCALE;
28796   jresult = (int)result;
28797   return jresult;
28798 }
28799
28800
28801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
28802   int jresult ;
28803   int result;
28804
28805   result = (int)Dali::Actor::Property::VISIBLE;
28806   jresult = (int)result;
28807   return jresult;
28808 }
28809
28810
28811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
28812   int jresult ;
28813   int result;
28814
28815   result = (int)Dali::Actor::Property::COLOR;
28816   jresult = (int)result;
28817   return jresult;
28818 }
28819
28820
28821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
28822   int jresult ;
28823   int result;
28824
28825   result = (int)Dali::Actor::Property::COLOR_RED;
28826   jresult = (int)result;
28827   return jresult;
28828 }
28829
28830
28831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
28832   int jresult ;
28833   int result;
28834
28835   result = (int)Dali::Actor::Property::COLOR_GREEN;
28836   jresult = (int)result;
28837   return jresult;
28838 }
28839
28840
28841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
28842   int jresult ;
28843   int result;
28844
28845   result = (int)Dali::Actor::Property::COLOR_BLUE;
28846   jresult = (int)result;
28847   return jresult;
28848 }
28849
28850
28851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
28852   int jresult ;
28853   int result;
28854
28855   result = (int)Dali::Actor::Property::COLOR_ALPHA;
28856   jresult = (int)result;
28857   return jresult;
28858 }
28859
28860
28861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
28862   int jresult ;
28863   int result;
28864
28865   result = (int)Dali::Actor::Property::WORLD_COLOR;
28866   jresult = (int)result;
28867   return jresult;
28868 }
28869
28870
28871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
28872   int jresult ;
28873   int result;
28874
28875   result = (int)Dali::Actor::Property::WORLD_MATRIX;
28876   jresult = (int)result;
28877   return jresult;
28878 }
28879
28880
28881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
28882   int jresult ;
28883   int result;
28884
28885   result = (int)Dali::Actor::Property::NAME;
28886   jresult = (int)result;
28887   return jresult;
28888 }
28889
28890
28891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
28892   int jresult ;
28893   int result;
28894
28895   result = (int)Dali::Actor::Property::SENSITIVE;
28896   jresult = (int)result;
28897   return jresult;
28898 }
28899
28900
28901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
28902   int jresult ;
28903   int result;
28904
28905   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
28906   jresult = (int)result;
28907   return jresult;
28908 }
28909
28910
28911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
28912   int jresult ;
28913   int result;
28914
28915   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
28916   jresult = (int)result;
28917   return jresult;
28918 }
28919
28920
28921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
28922   int jresult ;
28923   int result;
28924
28925   result = (int)Dali::Actor::Property::INHERIT_SCALE;
28926   jresult = (int)result;
28927   return jresult;
28928 }
28929
28930
28931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
28932   int jresult ;
28933   int result;
28934
28935   result = (int)Dali::Actor::Property::COLOR_MODE;
28936   jresult = (int)result;
28937   return jresult;
28938 }
28939
28940
28941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
28942   int jresult ;
28943   int result;
28944
28945   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
28946   jresult = (int)result;
28947   return jresult;
28948 }
28949
28950
28951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
28952   int jresult ;
28953   int result;
28954
28955   result = (int)Dali::Actor::Property::DRAW_MODE;
28956   jresult = (int)result;
28957   return jresult;
28958 }
28959
28960
28961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
28962   int jresult ;
28963   int result;
28964
28965   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
28966   jresult = (int)result;
28967   return jresult;
28968 }
28969
28970
28971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
28972   int jresult ;
28973   int result;
28974
28975   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
28976   jresult = (int)result;
28977   return jresult;
28978 }
28979
28980
28981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
28982   int jresult ;
28983   int result;
28984
28985   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
28986   jresult = (int)result;
28987   return jresult;
28988 }
28989
28990
28991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
28992   int jresult ;
28993   int result;
28994
28995   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
28996   jresult = (int)result;
28997   return jresult;
28998 }
28999
29000
29001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
29002   int jresult ;
29003   int result;
29004
29005   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
29006   jresult = (int)result;
29007   return jresult;
29008 }
29009
29010
29011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
29012   int jresult ;
29013   int result;
29014
29015   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
29016   jresult = (int)result;
29017   return jresult;
29018 }
29019
29020
29021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
29022   int jresult ;
29023   int result;
29024
29025   result = (int)Dali::Actor::Property::PADDING;
29026   jresult = (int)result;
29027   return jresult;
29028 }
29029
29030
29031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
29032   int jresult ;
29033   int result;
29034
29035   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
29036   jresult = (int)result;
29037   return jresult;
29038 }
29039
29040
29041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
29042   int jresult ;
29043   int result;
29044
29045   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
29046   jresult = (int)result;
29047   return jresult;
29048 }
29049
29050
29051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
29052   int jresult ;
29053   int result;
29054
29055   result = (int)Dali::Actor::Property::INHERIT_POSITION;
29056   jresult = (int)result;
29057   return jresult;
29058 }
29059
29060
29061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
29062   int jresult ;
29063   int result;
29064
29065   result = (int)Dali::Actor::Property::CLIPPING_MODE;
29066   jresult = (int)result;
29067   return jresult;
29068 }
29069
29070
29071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
29072   void * jresult ;
29073   Dali::Actor::Property *result = 0 ;
29074
29075   {
29076     try {
29077       result = (Dali::Actor::Property *)new Dali::Actor::Property();
29078     } catch (std::out_of_range& e) {
29079       {
29080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29081       };
29082     } catch (std::exception& e) {
29083       {
29084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29085       };
29086     } catch (...) {
29087       {
29088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29089       };
29090     }
29091   }
29092   jresult = (void *)result;
29093   return jresult;
29094 }
29095
29096
29097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
29098   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
29099
29100   arg1 = (Dali::Actor::Property *)jarg1;
29101   {
29102     try {
29103       delete arg1;
29104     } catch (std::out_of_range& e) {
29105       {
29106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29107       };
29108     } catch (std::exception& e) {
29109       {
29110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29111       };
29112     } catch (...) {
29113       {
29114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29115       };
29116     }
29117   }
29118 }
29119
29120
29121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
29122   void * jresult ;
29123   Dali::Actor *result = 0 ;
29124
29125   {
29126     try {
29127       result = (Dali::Actor *)new Dali::Actor();
29128     } catch (std::out_of_range& e) {
29129       {
29130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29131       };
29132     } catch (std::exception& e) {
29133       {
29134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29135       };
29136     } catch (...) {
29137       {
29138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29139       };
29140     }
29141   }
29142   jresult = (void *)result;
29143   return jresult;
29144 }
29145
29146
29147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29148   void * jresult ;
29149   Dali::Actor result;
29150
29151   {
29152     try {
29153       result = Dali::Actor::New();
29154     } catch (std::out_of_range& e) {
29155       {
29156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29157       };
29158     } catch (std::exception& e) {
29159       {
29160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29161       };
29162     } catch (...) {
29163       {
29164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29165       };
29166     }
29167   }
29168   jresult = new Dali::Actor((const Dali::Actor &)result);
29169   return jresult;
29170 }
29171
29172
29173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29174   void * jresult ;
29175   Dali::BaseHandle arg1 ;
29176   Dali::BaseHandle *argp1 ;
29177   Dali::Actor result;
29178
29179   argp1 = (Dali::BaseHandle *)jarg1;
29180   if (!argp1) {
29181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29182     return 0;
29183   }
29184   arg1 = *argp1;
29185   {
29186     try {
29187       result = Dali::Actor::DownCast(arg1);
29188     } catch (std::out_of_range& e) {
29189       {
29190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29191       };
29192     } catch (std::exception& e) {
29193       {
29194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29195       };
29196     } catch (...) {
29197       {
29198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29199       };
29200     }
29201   }
29202   jresult = new Dali::Actor((const Dali::Actor &)result);
29203   return jresult;
29204 }
29205
29206
29207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29208   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29209
29210   arg1 = (Dali::Actor *)jarg1;
29211   {
29212     try {
29213       delete arg1;
29214     } catch (std::out_of_range& e) {
29215       {
29216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29217       };
29218     } catch (std::exception& e) {
29219       {
29220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29221       };
29222     } catch (...) {
29223       {
29224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29225       };
29226     }
29227   }
29228 }
29229
29230
29231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29232   void * jresult ;
29233   Dali::Actor *arg1 = 0 ;
29234   Dali::Actor *result = 0 ;
29235
29236   arg1 = (Dali::Actor *)jarg1;
29237   if (!arg1) {
29238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29239     return 0;
29240   }
29241   {
29242     try {
29243       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29244     } catch (std::out_of_range& e) {
29245       {
29246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29247       };
29248     } catch (std::exception& e) {
29249       {
29250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29251       };
29252     } catch (...) {
29253       {
29254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29255       };
29256     }
29257   }
29258   jresult = (void *)result;
29259   return jresult;
29260 }
29261
29262
29263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29264   void * jresult ;
29265   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29266   Dali::Actor *arg2 = 0 ;
29267   Dali::Actor *result = 0 ;
29268
29269   arg1 = (Dali::Actor *)jarg1;
29270   arg2 = (Dali::Actor *)jarg2;
29271   if (!arg2) {
29272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29273     return 0;
29274   }
29275   {
29276     try {
29277       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29278     } catch (std::out_of_range& e) {
29279       {
29280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29281       };
29282     } catch (std::exception& e) {
29283       {
29284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29285       };
29286     } catch (...) {
29287       {
29288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29289       };
29290     }
29291   }
29292   jresult = (void *)result;
29293   return jresult;
29294 }
29295
29296
29297 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29298   char * jresult ;
29299   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29300   std::string *result = 0 ;
29301
29302   arg1 = (Dali::Actor *)jarg1;
29303   {
29304     try {
29305       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29306     } catch (std::out_of_range& e) {
29307       {
29308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29309       };
29310     } catch (std::exception& e) {
29311       {
29312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29313       };
29314     } catch (...) {
29315       {
29316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29317       };
29318     }
29319   }
29320   jresult = SWIG_csharp_string_callback(result->c_str());
29321   return jresult;
29322 }
29323
29324
29325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29326   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29327   std::string *arg2 = 0 ;
29328
29329   arg1 = (Dali::Actor *)jarg1;
29330   if (!jarg2) {
29331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29332     return ;
29333   }
29334   std::string arg2_str(jarg2);
29335   arg2 = &arg2_str;
29336   {
29337     try {
29338       (arg1)->SetName((std::string const &)*arg2);
29339     } catch (std::out_of_range& e) {
29340       {
29341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29342       };
29343     } catch (std::exception& e) {
29344       {
29345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29346       };
29347     } catch (...) {
29348       {
29349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29350       };
29351     }
29352   }
29353
29354   //argout typemap for const std::string&
29355
29356 }
29357
29358
29359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29360   unsigned int jresult ;
29361   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29362   unsigned int result;
29363
29364   arg1 = (Dali::Actor *)jarg1;
29365   {
29366     try {
29367       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29368     } catch (std::out_of_range& e) {
29369       {
29370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29371       };
29372     } catch (std::exception& e) {
29373       {
29374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29375       };
29376     } catch (...) {
29377       {
29378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29379       };
29380     }
29381   }
29382   jresult = result;
29383   return jresult;
29384 }
29385
29386
29387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29388   unsigned int jresult ;
29389   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29390   bool result;
29391
29392   arg1 = (Dali::Actor *)jarg1;
29393   {
29394     try {
29395       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29396     } catch (std::out_of_range& e) {
29397       {
29398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29399       };
29400     } catch (std::exception& e) {
29401       {
29402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29403       };
29404     } catch (...) {
29405       {
29406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29407       };
29408     }
29409   }
29410   jresult = result;
29411   return jresult;
29412 }
29413
29414
29415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29416   unsigned int jresult ;
29417   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29418   bool result;
29419
29420   arg1 = (Dali::Actor *)jarg1;
29421   {
29422     try {
29423       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29424     } catch (std::out_of_range& e) {
29425       {
29426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29427       };
29428     } catch (std::exception& e) {
29429       {
29430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29431       };
29432     } catch (...) {
29433       {
29434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29435       };
29436     }
29437   }
29438   jresult = result;
29439   return jresult;
29440 }
29441
29442
29443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29444   unsigned int jresult ;
29445   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29446   bool result;
29447
29448   arg1 = (Dali::Actor *)jarg1;
29449   {
29450     try {
29451       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29452     } catch (std::out_of_range& e) {
29453       {
29454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29455       };
29456     } catch (std::exception& e) {
29457       {
29458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29459       };
29460     } catch (...) {
29461       {
29462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29463       };
29464     }
29465   }
29466   jresult = result;
29467   return jresult;
29468 }
29469
29470
29471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29472   void * jresult ;
29473   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29474   Dali::Layer result;
29475
29476   arg1 = (Dali::Actor *)jarg1;
29477   {
29478     try {
29479       result = (arg1)->GetLayer();
29480     } catch (std::out_of_range& e) {
29481       {
29482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29483       };
29484     } catch (std::exception& e) {
29485       {
29486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29487       };
29488     } catch (...) {
29489       {
29490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29491       };
29492     }
29493   }
29494   jresult = new Dali::Layer((const Dali::Layer &)result);
29495   return jresult;
29496 }
29497
29498
29499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29500   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29501   Dali::Actor arg2 ;
29502   Dali::Actor *argp2 ;
29503
29504   arg1 = (Dali::Actor *)jarg1;
29505   argp2 = (Dali::Actor *)jarg2;
29506   if (!argp2) {
29507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29508     return ;
29509   }
29510   arg2 = *argp2;
29511   {
29512     try {
29513       (arg1)->Add(arg2);
29514     } catch (std::out_of_range& e) {
29515       {
29516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29517       };
29518     } catch (std::exception& e) {
29519       {
29520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29521       };
29522     } catch (...) {
29523       {
29524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29525       };
29526     }
29527   }
29528 }
29529
29530
29531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29532   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29533   Dali::Actor arg2 ;
29534   Dali::Actor *argp2 ;
29535
29536   arg1 = (Dali::Actor *)jarg1;
29537   argp2 = (Dali::Actor *)jarg2;
29538   if (!argp2) {
29539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29540     return ;
29541   }
29542   arg2 = *argp2;
29543   {
29544     try {
29545       (arg1)->Remove(arg2);
29546     } catch (std::out_of_range& e) {
29547       {
29548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29549       };
29550     } catch (std::exception& e) {
29551       {
29552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29553       };
29554     } catch (...) {
29555       {
29556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29557       };
29558     }
29559   }
29560 }
29561
29562
29563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29564   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29565
29566   arg1 = (Dali::Actor *)jarg1;
29567   {
29568     try {
29569       (arg1)->Unparent();
29570     } catch (std::out_of_range& e) {
29571       {
29572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29573       };
29574     } catch (std::exception& e) {
29575       {
29576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29577       };
29578     } catch (...) {
29579       {
29580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29581       };
29582     }
29583   }
29584 }
29585
29586
29587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29588   unsigned int jresult ;
29589   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29590   unsigned int result;
29591
29592   arg1 = (Dali::Actor *)jarg1;
29593   {
29594     try {
29595       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
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 = result;
29611   return jresult;
29612 }
29613
29614
29615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29616   void * jresult ;
29617   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29618   unsigned int arg2 ;
29619   Dali::Actor result;
29620
29621   arg1 = (Dali::Actor *)jarg1;
29622   arg2 = (unsigned int)jarg2;
29623   {
29624     try {
29625       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29626     } catch (std::out_of_range& e) {
29627       {
29628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29629       };
29630     } catch (std::exception& e) {
29631       {
29632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29633       };
29634     } catch (...) {
29635       {
29636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29637       };
29638     }
29639   }
29640   jresult = new Dali::Actor((const Dali::Actor &)result);
29641   return jresult;
29642 }
29643
29644
29645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29646   void * jresult ;
29647   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29648   std::string *arg2 = 0 ;
29649   Dali::Actor result;
29650
29651   arg1 = (Dali::Actor *)jarg1;
29652   if (!jarg2) {
29653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29654     return 0;
29655   }
29656   std::string arg2_str(jarg2);
29657   arg2 = &arg2_str;
29658   {
29659     try {
29660       result = (arg1)->FindChildByName((std::string const &)*arg2);
29661     } catch (std::out_of_range& e) {
29662       {
29663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29664       };
29665     } catch (std::exception& e) {
29666       {
29667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29668       };
29669     } catch (...) {
29670       {
29671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29672       };
29673     }
29674   }
29675   jresult = new Dali::Actor((const Dali::Actor &)result);
29676
29677   //argout typemap for const std::string&
29678
29679   return jresult;
29680 }
29681
29682
29683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29684   void * jresult ;
29685   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29686   unsigned int arg2 ;
29687   Dali::Actor result;
29688
29689   arg1 = (Dali::Actor *)jarg1;
29690   arg2 = (unsigned int)jarg2;
29691   {
29692     try {
29693       result = (arg1)->FindChildById(arg2);
29694     } catch (std::out_of_range& e) {
29695       {
29696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29697       };
29698     } catch (std::exception& e) {
29699       {
29700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29701       };
29702     } catch (...) {
29703       {
29704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29705       };
29706     }
29707   }
29708   jresult = new Dali::Actor((const Dali::Actor &)result);
29709   return jresult;
29710 }
29711
29712
29713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29714   void * jresult ;
29715   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29716   Dali::Actor result;
29717
29718   arg1 = (Dali::Actor *)jarg1;
29719   {
29720     try {
29721       result = ((Dali::Actor const *)arg1)->GetParent();
29722     } catch (std::out_of_range& e) {
29723       {
29724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29725       };
29726     } catch (std::exception& e) {
29727       {
29728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29729       };
29730     } catch (...) {
29731       {
29732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29733       };
29734     }
29735   }
29736   jresult = new Dali::Actor((const Dali::Actor &)result);
29737   return jresult;
29738 }
29739
29740
29741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29742   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29743   Dali::Vector3 *arg2 = 0 ;
29744
29745   arg1 = (Dali::Actor *)jarg1;
29746   arg2 = (Dali::Vector3 *)jarg2;
29747   if (!arg2) {
29748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29749     return ;
29750   }
29751   {
29752     try {
29753       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
29754     } catch (std::out_of_range& e) {
29755       {
29756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29757       };
29758     } catch (std::exception& e) {
29759       {
29760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29761       };
29762     } catch (...) {
29763       {
29764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29765       };
29766     }
29767   }
29768 }
29769
29770
29771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
29772   void * jresult ;
29773   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29774   Dali::Vector3 result;
29775
29776   arg1 = (Dali::Actor *)jarg1;
29777   {
29778     try {
29779       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29780     } catch (std::out_of_range& e) {
29781       {
29782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29783       };
29784     } catch (std::exception& e) {
29785       {
29786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29787       };
29788     } catch (...) {
29789       {
29790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29791       };
29792     }
29793   }
29794   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29795   return jresult;
29796 }
29797
29798
29799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29800   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29801   Dali::Vector3 *arg2 = 0 ;
29802
29803   arg1 = (Dali::Actor *)jarg1;
29804   arg2 = (Dali::Vector3 *)jarg2;
29805   if (!arg2) {
29806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29807     return ;
29808   }
29809   {
29810     try {
29811       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29812     } catch (std::out_of_range& e) {
29813       {
29814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29815       };
29816     } catch (std::exception& e) {
29817       {
29818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29819       };
29820     } catch (...) {
29821       {
29822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29823       };
29824     }
29825   }
29826 }
29827
29828
29829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
29830   void * jresult ;
29831   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29832   Dali::Vector3 result;
29833
29834   arg1 = (Dali::Actor *)jarg1;
29835   {
29836     try {
29837       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
29838     } catch (std::out_of_range& e) {
29839       {
29840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29841       };
29842     } catch (std::exception& e) {
29843       {
29844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29845       };
29846     } catch (...) {
29847       {
29848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29849       };
29850     }
29851   }
29852   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29853   return jresult;
29854 }
29855
29856
29857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29859   float arg2 ;
29860   float arg3 ;
29861
29862   arg1 = (Dali::Actor *)jarg1;
29863   arg2 = (float)jarg2;
29864   arg3 = (float)jarg3;
29865   {
29866     try {
29867       (arg1)->SetSize(arg2,arg3);
29868     } catch (std::out_of_range& e) {
29869       {
29870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29871       };
29872     } catch (std::exception& e) {
29873       {
29874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29875       };
29876     } catch (...) {
29877       {
29878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29879       };
29880     }
29881   }
29882 }
29883
29884
29885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29886   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29887   float arg2 ;
29888   float arg3 ;
29889   float arg4 ;
29890
29891   arg1 = (Dali::Actor *)jarg1;
29892   arg2 = (float)jarg2;
29893   arg3 = (float)jarg3;
29894   arg4 = (float)jarg4;
29895   {
29896     try {
29897       (arg1)->SetSize(arg2,arg3,arg4);
29898     } catch (std::out_of_range& e) {
29899       {
29900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29901       };
29902     } catch (std::exception& e) {
29903       {
29904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29905       };
29906     } catch (...) {
29907       {
29908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29909       };
29910     }
29911   }
29912 }
29913
29914
29915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
29916   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29917   Dali::Vector2 *arg2 = 0 ;
29918
29919   arg1 = (Dali::Actor *)jarg1;
29920   arg2 = (Dali::Vector2 *)jarg2;
29921   if (!arg2) {
29922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29923     return ;
29924   }
29925   {
29926     try {
29927       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
29928     } catch (std::out_of_range& e) {
29929       {
29930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29931       };
29932     } catch (std::exception& e) {
29933       {
29934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29935       };
29936     } catch (...) {
29937       {
29938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29939       };
29940     }
29941   }
29942 }
29943
29944
29945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
29946   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29947   Dali::Vector3 *arg2 = 0 ;
29948
29949   arg1 = (Dali::Actor *)jarg1;
29950   arg2 = (Dali::Vector3 *)jarg2;
29951   if (!arg2) {
29952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29953     return ;
29954   }
29955   {
29956     try {
29957       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
29958     } catch (std::out_of_range& e) {
29959       {
29960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29961       };
29962     } catch (std::exception& e) {
29963       {
29964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29965       };
29966     } catch (...) {
29967       {
29968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29969       };
29970     }
29971   }
29972 }
29973
29974
29975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
29976   void * jresult ;
29977   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29978   Dali::Vector3 result;
29979
29980   arg1 = (Dali::Actor *)jarg1;
29981   {
29982     try {
29983       result = ((Dali::Actor const *)arg1)->GetTargetSize();
29984     } catch (std::out_of_range& e) {
29985       {
29986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29987       };
29988     } catch (std::exception& e) {
29989       {
29990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29991       };
29992     } catch (...) {
29993       {
29994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29995       };
29996     }
29997   }
29998   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29999   return jresult;
30000 }
30001
30002
30003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
30004   void * jresult ;
30005   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30006   Dali::Vector3 result;
30007
30008   arg1 = (Dali::Actor *)jarg1;
30009   {
30010     try {
30011       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
30012     } catch (std::out_of_range& e) {
30013       {
30014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30015       };
30016     } catch (std::exception& e) {
30017       {
30018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30019       };
30020     } catch (...) {
30021       {
30022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30023       };
30024     }
30025   }
30026   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30027   return jresult;
30028 }
30029
30030
30031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
30032   void * jresult ;
30033   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30034   Dali::Vector3 result;
30035
30036   arg1 = (Dali::Actor *)jarg1;
30037   {
30038     try {
30039       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
30040     } catch (std::out_of_range& e) {
30041       {
30042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30043       };
30044     } catch (std::exception& e) {
30045       {
30046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30047       };
30048     } catch (...) {
30049       {
30050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30051       };
30052     }
30053   }
30054   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30055   return jresult;
30056 }
30057
30058
30059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30060   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30061   float arg2 ;
30062   float arg3 ;
30063
30064   arg1 = (Dali::Actor *)jarg1;
30065   arg2 = (float)jarg2;
30066   arg3 = (float)jarg3;
30067   {
30068     try {
30069       (arg1)->SetPosition(arg2,arg3);
30070     } catch (std::out_of_range& e) {
30071       {
30072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30073       };
30074     } catch (std::exception& e) {
30075       {
30076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30077       };
30078     } catch (...) {
30079       {
30080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30081       };
30082     }
30083   }
30084 }
30085
30086
30087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30088   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30089   float arg2 ;
30090   float arg3 ;
30091   float arg4 ;
30092
30093   arg1 = (Dali::Actor *)jarg1;
30094   arg2 = (float)jarg2;
30095   arg3 = (float)jarg3;
30096   arg4 = (float)jarg4;
30097   {
30098     try {
30099       (arg1)->SetPosition(arg2,arg3,arg4);
30100     } catch (std::out_of_range& e) {
30101       {
30102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30103       };
30104     } catch (std::exception& e) {
30105       {
30106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30107       };
30108     } catch (...) {
30109       {
30110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30111       };
30112     }
30113   }
30114 }
30115
30116
30117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
30118   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30119   Dali::Vector3 *arg2 = 0 ;
30120
30121   arg1 = (Dali::Actor *)jarg1;
30122   arg2 = (Dali::Vector3 *)jarg2;
30123   if (!arg2) {
30124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30125     return ;
30126   }
30127   {
30128     try {
30129       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30130     } catch (std::out_of_range& e) {
30131       {
30132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30133       };
30134     } catch (std::exception& e) {
30135       {
30136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30137       };
30138     } catch (...) {
30139       {
30140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30141       };
30142     }
30143   }
30144 }
30145
30146
30147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30148   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30149   float arg2 ;
30150
30151   arg1 = (Dali::Actor *)jarg1;
30152   arg2 = (float)jarg2;
30153   {
30154     try {
30155       (arg1)->SetX(arg2);
30156     } catch (std::out_of_range& e) {
30157       {
30158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30159       };
30160     } catch (std::exception& e) {
30161       {
30162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30163       };
30164     } catch (...) {
30165       {
30166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30167       };
30168     }
30169   }
30170 }
30171
30172
30173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30174   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30175   float arg2 ;
30176
30177   arg1 = (Dali::Actor *)jarg1;
30178   arg2 = (float)jarg2;
30179   {
30180     try {
30181       (arg1)->SetY(arg2);
30182     } catch (std::out_of_range& e) {
30183       {
30184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30185       };
30186     } catch (std::exception& e) {
30187       {
30188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30189       };
30190     } catch (...) {
30191       {
30192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30193       };
30194     }
30195   }
30196 }
30197
30198
30199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30200   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30201   float arg2 ;
30202
30203   arg1 = (Dali::Actor *)jarg1;
30204   arg2 = (float)jarg2;
30205   {
30206     try {
30207       (arg1)->SetZ(arg2);
30208     } catch (std::out_of_range& e) {
30209       {
30210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30211       };
30212     } catch (std::exception& e) {
30213       {
30214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30215       };
30216     } catch (...) {
30217       {
30218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30219       };
30220     }
30221   }
30222 }
30223
30224
30225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30226   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30227   Dali::Vector3 *arg2 = 0 ;
30228
30229   arg1 = (Dali::Actor *)jarg1;
30230   arg2 = (Dali::Vector3 *)jarg2;
30231   if (!arg2) {
30232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30233     return ;
30234   }
30235   {
30236     try {
30237       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30238     } catch (std::out_of_range& e) {
30239       {
30240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30241       };
30242     } catch (std::exception& e) {
30243       {
30244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30245       };
30246     } catch (...) {
30247       {
30248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30249       };
30250     }
30251   }
30252 }
30253
30254
30255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30256   void * jresult ;
30257   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30258   Dali::Vector3 result;
30259
30260   arg1 = (Dali::Actor *)jarg1;
30261   {
30262     try {
30263       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30264     } catch (std::out_of_range& e) {
30265       {
30266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30267       };
30268     } catch (std::exception& e) {
30269       {
30270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30271       };
30272     } catch (...) {
30273       {
30274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30275       };
30276     }
30277   }
30278   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30279   return jresult;
30280 }
30281
30282
30283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30284   void * jresult ;
30285   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30286   Dali::Vector3 result;
30287
30288   arg1 = (Dali::Actor *)jarg1;
30289   {
30290     try {
30291       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30292     } catch (std::out_of_range& e) {
30293       {
30294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30295       };
30296     } catch (std::exception& e) {
30297       {
30298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30299       };
30300     } catch (...) {
30301       {
30302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30303       };
30304     }
30305   }
30306   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30307   return jresult;
30308 }
30309
30310
30311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30312   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30313   bool arg2 ;
30314
30315   arg1 = (Dali::Actor *)jarg1;
30316   arg2 = jarg2 ? true : false;
30317   {
30318     try {
30319       (arg1)->SetInheritPosition(arg2);
30320     } catch (std::out_of_range& e) {
30321       {
30322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30323       };
30324     } catch (std::exception& e) {
30325       {
30326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30327       };
30328     } catch (...) {
30329       {
30330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30331       };
30332     }
30333   }
30334 }
30335
30336
30337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30338   int jresult ;
30339   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30340   Dali::PositionInheritanceMode result;
30341
30342   arg1 = (Dali::Actor *)jarg1;
30343   {
30344     try {
30345       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30346     } catch (std::out_of_range& e) {
30347       {
30348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30349       };
30350     } catch (std::exception& e) {
30351       {
30352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30353       };
30354     } catch (...) {
30355       {
30356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30357       };
30358     }
30359   }
30360   jresult = (int)result;
30361   return jresult;
30362 }
30363
30364
30365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30366   unsigned int jresult ;
30367   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30368   bool result;
30369
30370   arg1 = (Dali::Actor *)jarg1;
30371   {
30372     try {
30373       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30374     } catch (std::out_of_range& e) {
30375       {
30376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30377       };
30378     } catch (std::exception& e) {
30379       {
30380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30381       };
30382     } catch (...) {
30383       {
30384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30385       };
30386     }
30387   }
30388   jresult = result;
30389   return jresult;
30390 }
30391
30392
30393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30394   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30395   Dali::Degree *arg2 = 0 ;
30396   Dali::Vector3 *arg3 = 0 ;
30397
30398   arg1 = (Dali::Actor *)jarg1;
30399   arg2 = (Dali::Degree *)jarg2;
30400   if (!arg2) {
30401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30402     return ;
30403   }
30404   arg3 = (Dali::Vector3 *)jarg3;
30405   if (!arg3) {
30406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30407     return ;
30408   }
30409   {
30410     try {
30411       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30412     } catch (std::out_of_range& e) {
30413       {
30414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30415       };
30416     } catch (std::exception& e) {
30417       {
30418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30419       };
30420     } catch (...) {
30421       {
30422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30423       };
30424     }
30425   }
30426 }
30427
30428
30429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30430   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30431   Dali::Radian *arg2 = 0 ;
30432   Dali::Vector3 *arg3 = 0 ;
30433
30434   arg1 = (Dali::Actor *)jarg1;
30435   arg2 = (Dali::Radian *)jarg2;
30436   if (!arg2) {
30437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30438     return ;
30439   }
30440   arg3 = (Dali::Vector3 *)jarg3;
30441   if (!arg3) {
30442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30443     return ;
30444   }
30445   {
30446     try {
30447       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30448     } catch (std::out_of_range& e) {
30449       {
30450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30451       };
30452     } catch (std::exception& e) {
30453       {
30454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30455       };
30456     } catch (...) {
30457       {
30458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30459       };
30460     }
30461   }
30462 }
30463
30464
30465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30466   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30467   Dali::Quaternion *arg2 = 0 ;
30468
30469   arg1 = (Dali::Actor *)jarg1;
30470   arg2 = (Dali::Quaternion *)jarg2;
30471   if (!arg2) {
30472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30473     return ;
30474   }
30475   {
30476     try {
30477       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30478     } catch (std::out_of_range& e) {
30479       {
30480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30481       };
30482     } catch (std::exception& e) {
30483       {
30484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30485       };
30486     } catch (...) {
30487       {
30488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30489       };
30490     }
30491   }
30492 }
30493
30494
30495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30496   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30497   Dali::Degree *arg2 = 0 ;
30498   Dali::Vector3 *arg3 = 0 ;
30499
30500   arg1 = (Dali::Actor *)jarg1;
30501   arg2 = (Dali::Degree *)jarg2;
30502   if (!arg2) {
30503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30504     return ;
30505   }
30506   arg3 = (Dali::Vector3 *)jarg3;
30507   if (!arg3) {
30508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30509     return ;
30510   }
30511   {
30512     try {
30513       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30514     } catch (std::out_of_range& e) {
30515       {
30516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30517       };
30518     } catch (std::exception& e) {
30519       {
30520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30521       };
30522     } catch (...) {
30523       {
30524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30525       };
30526     }
30527   }
30528 }
30529
30530
30531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30532   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30533   Dali::Radian *arg2 = 0 ;
30534   Dali::Vector3 *arg3 = 0 ;
30535
30536   arg1 = (Dali::Actor *)jarg1;
30537   arg2 = (Dali::Radian *)jarg2;
30538   if (!arg2) {
30539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30540     return ;
30541   }
30542   arg3 = (Dali::Vector3 *)jarg3;
30543   if (!arg3) {
30544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30545     return ;
30546   }
30547   {
30548     try {
30549       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30550     } catch (std::out_of_range& e) {
30551       {
30552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30553       };
30554     } catch (std::exception& e) {
30555       {
30556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30557       };
30558     } catch (...) {
30559       {
30560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30561       };
30562     }
30563   }
30564 }
30565
30566
30567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30568   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30569   Dali::Quaternion *arg2 = 0 ;
30570
30571   arg1 = (Dali::Actor *)jarg1;
30572   arg2 = (Dali::Quaternion *)jarg2;
30573   if (!arg2) {
30574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30575     return ;
30576   }
30577   {
30578     try {
30579       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30580     } catch (std::out_of_range& e) {
30581       {
30582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30583       };
30584     } catch (std::exception& e) {
30585       {
30586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30587       };
30588     } catch (...) {
30589       {
30590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30591       };
30592     }
30593   }
30594 }
30595
30596
30597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30598   void * jresult ;
30599   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30600   Dali::Quaternion result;
30601
30602   arg1 = (Dali::Actor *)jarg1;
30603   {
30604     try {
30605       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30606     } catch (std::out_of_range& e) {
30607       {
30608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30609       };
30610     } catch (std::exception& e) {
30611       {
30612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30613       };
30614     } catch (...) {
30615       {
30616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30617       };
30618     }
30619   }
30620   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30621   return jresult;
30622 }
30623
30624
30625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30626   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30627   bool arg2 ;
30628
30629   arg1 = (Dali::Actor *)jarg1;
30630   arg2 = jarg2 ? true : false;
30631   {
30632     try {
30633       (arg1)->SetInheritOrientation(arg2);
30634     } catch (std::out_of_range& e) {
30635       {
30636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30637       };
30638     } catch (std::exception& e) {
30639       {
30640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30641       };
30642     } catch (...) {
30643       {
30644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30645       };
30646     }
30647   }
30648 }
30649
30650
30651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30652   unsigned int jresult ;
30653   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30654   bool result;
30655
30656   arg1 = (Dali::Actor *)jarg1;
30657   {
30658     try {
30659       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30660     } catch (std::out_of_range& e) {
30661       {
30662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30663       };
30664     } catch (std::exception& e) {
30665       {
30666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30667       };
30668     } catch (...) {
30669       {
30670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30671       };
30672     }
30673   }
30674   jresult = result;
30675   return jresult;
30676 }
30677
30678
30679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30680   void * jresult ;
30681   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30682   Dali::Quaternion result;
30683
30684   arg1 = (Dali::Actor *)jarg1;
30685   {
30686     try {
30687       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30688     } catch (std::out_of_range& e) {
30689       {
30690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30691       };
30692     } catch (std::exception& e) {
30693       {
30694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30695       };
30696     } catch (...) {
30697       {
30698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30699       };
30700     }
30701   }
30702   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30703   return jresult;
30704 }
30705
30706
30707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30708   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30709   float arg2 ;
30710
30711   arg1 = (Dali::Actor *)jarg1;
30712   arg2 = (float)jarg2;
30713   {
30714     try {
30715       (arg1)->SetScale(arg2);
30716     } catch (std::out_of_range& e) {
30717       {
30718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30719       };
30720     } catch (std::exception& e) {
30721       {
30722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30723       };
30724     } catch (...) {
30725       {
30726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30727       };
30728     }
30729   }
30730 }
30731
30732
30733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30734   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30735   float arg2 ;
30736   float arg3 ;
30737   float arg4 ;
30738
30739   arg1 = (Dali::Actor *)jarg1;
30740   arg2 = (float)jarg2;
30741   arg3 = (float)jarg3;
30742   arg4 = (float)jarg4;
30743   {
30744     try {
30745       (arg1)->SetScale(arg2,arg3,arg4);
30746     } catch (std::out_of_range& e) {
30747       {
30748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30749       };
30750     } catch (std::exception& e) {
30751       {
30752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30753       };
30754     } catch (...) {
30755       {
30756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30757       };
30758     }
30759   }
30760 }
30761
30762
30763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30764   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30765   Dali::Vector3 *arg2 = 0 ;
30766
30767   arg1 = (Dali::Actor *)jarg1;
30768   arg2 = (Dali::Vector3 *)jarg2;
30769   if (!arg2) {
30770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30771     return ;
30772   }
30773   {
30774     try {
30775       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30776     } catch (std::out_of_range& e) {
30777       {
30778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30779       };
30780     } catch (std::exception& e) {
30781       {
30782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30783       };
30784     } catch (...) {
30785       {
30786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30787       };
30788     }
30789   }
30790 }
30791
30792
30793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
30794   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30795   Dali::Vector3 *arg2 = 0 ;
30796
30797   arg1 = (Dali::Actor *)jarg1;
30798   arg2 = (Dali::Vector3 *)jarg2;
30799   if (!arg2) {
30800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30801     return ;
30802   }
30803   {
30804     try {
30805       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30806     } catch (std::out_of_range& e) {
30807       {
30808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30809       };
30810     } catch (std::exception& e) {
30811       {
30812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30813       };
30814     } catch (...) {
30815       {
30816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30817       };
30818     }
30819   }
30820 }
30821
30822
30823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
30824   void * jresult ;
30825   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30826   Dali::Vector3 result;
30827
30828   arg1 = (Dali::Actor *)jarg1;
30829   {
30830     try {
30831       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
30832     } catch (std::out_of_range& e) {
30833       {
30834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30835       };
30836     } catch (std::exception& e) {
30837       {
30838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30839       };
30840     } catch (...) {
30841       {
30842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30843       };
30844     }
30845   }
30846   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30847   return jresult;
30848 }
30849
30850
30851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
30852   void * jresult ;
30853   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30854   Dali::Vector3 result;
30855
30856   arg1 = (Dali::Actor *)jarg1;
30857   {
30858     try {
30859       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
30860     } catch (std::out_of_range& e) {
30861       {
30862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30863       };
30864     } catch (std::exception& e) {
30865       {
30866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30867       };
30868     } catch (...) {
30869       {
30870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30871       };
30872     }
30873   }
30874   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30875   return jresult;
30876 }
30877
30878
30879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
30880   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30881   bool arg2 ;
30882
30883   arg1 = (Dali::Actor *)jarg1;
30884   arg2 = jarg2 ? true : false;
30885   {
30886     try {
30887       (arg1)->SetInheritScale(arg2);
30888     } catch (std::out_of_range& e) {
30889       {
30890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30891       };
30892     } catch (std::exception& e) {
30893       {
30894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30895       };
30896     } catch (...) {
30897       {
30898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30899       };
30900     }
30901   }
30902 }
30903
30904
30905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
30906   unsigned int jresult ;
30907   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30908   bool result;
30909
30910   arg1 = (Dali::Actor *)jarg1;
30911   {
30912     try {
30913       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
30914     } catch (std::out_of_range& e) {
30915       {
30916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30917       };
30918     } catch (std::exception& e) {
30919       {
30920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30921       };
30922     } catch (...) {
30923       {
30924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30925       };
30926     }
30927   }
30928   jresult = result;
30929   return jresult;
30930 }
30931
30932
30933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
30934   void * jresult ;
30935   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30936   Dali::Matrix result;
30937
30938   arg1 = (Dali::Actor *)jarg1;
30939   {
30940     try {
30941       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
30942     } catch (std::out_of_range& e) {
30943       {
30944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30945       };
30946     } catch (std::exception& e) {
30947       {
30948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30949       };
30950     } catch (...) {
30951       {
30952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30953       };
30954     }
30955   }
30956   jresult = new Dali::Matrix((const Dali::Matrix &)result);
30957   return jresult;
30958 }
30959
30960
30961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
30962   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30963   bool arg2 ;
30964
30965   arg1 = (Dali::Actor *)jarg1;
30966   arg2 = jarg2 ? true : false;
30967   {
30968     try {
30969       (arg1)->SetVisible(arg2);
30970     } catch (std::out_of_range& e) {
30971       {
30972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30973       };
30974     } catch (std::exception& e) {
30975       {
30976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30977       };
30978     } catch (...) {
30979       {
30980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30981       };
30982     }
30983   }
30984 }
30985
30986
30987 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
30988   unsigned int jresult ;
30989   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30990   bool result;
30991
30992   arg1 = (Dali::Actor *)jarg1;
30993   {
30994     try {
30995       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
30996     } catch (std::out_of_range& e) {
30997       {
30998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30999       };
31000     } catch (std::exception& e) {
31001       {
31002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31003       };
31004     } catch (...) {
31005       {
31006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31007       };
31008     }
31009   }
31010   jresult = result;
31011   return jresult;
31012 }
31013
31014
31015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
31016   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31017   float arg2 ;
31018
31019   arg1 = (Dali::Actor *)jarg1;
31020   arg2 = (float)jarg2;
31021   {
31022     try {
31023       (arg1)->SetOpacity(arg2);
31024     } catch (std::out_of_range& e) {
31025       {
31026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31027       };
31028     } catch (std::exception& e) {
31029       {
31030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31031       };
31032     } catch (...) {
31033       {
31034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31035       };
31036     }
31037   }
31038 }
31039
31040
31041 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
31042   float jresult ;
31043   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31044   float result;
31045
31046   arg1 = (Dali::Actor *)jarg1;
31047   {
31048     try {
31049       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
31050     } catch (std::out_of_range& e) {
31051       {
31052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31053       };
31054     } catch (std::exception& e) {
31055       {
31056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31057       };
31058     } catch (...) {
31059       {
31060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31061       };
31062     }
31063   }
31064   jresult = result;
31065   return jresult;
31066 }
31067
31068
31069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
31070   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31071   Dali::Vector4 *arg2 = 0 ;
31072
31073   arg1 = (Dali::Actor *)jarg1;
31074   arg2 = (Dali::Vector4 *)jarg2;
31075   if (!arg2) {
31076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
31077     return ;
31078   }
31079   {
31080     try {
31081       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
31082     } catch (std::out_of_range& e) {
31083       {
31084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31085       };
31086     } catch (std::exception& e) {
31087       {
31088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31089       };
31090     } catch (...) {
31091       {
31092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31093       };
31094     }
31095   }
31096 }
31097
31098
31099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
31100   void * jresult ;
31101   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31102   Dali::Vector4 result;
31103
31104   arg1 = (Dali::Actor *)jarg1;
31105   {
31106     try {
31107       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
31108     } catch (std::out_of_range& e) {
31109       {
31110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31111       };
31112     } catch (std::exception& e) {
31113       {
31114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31115       };
31116     } catch (...) {
31117       {
31118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31119       };
31120     }
31121   }
31122   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31123   return jresult;
31124 }
31125
31126
31127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31128   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31129   Dali::ColorMode arg2 ;
31130
31131   arg1 = (Dali::Actor *)jarg1;
31132   arg2 = (Dali::ColorMode)jarg2;
31133   {
31134     try {
31135       (arg1)->SetColorMode(arg2);
31136     } catch (std::out_of_range& e) {
31137       {
31138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31139       };
31140     } catch (std::exception& e) {
31141       {
31142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31143       };
31144     } catch (...) {
31145       {
31146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31147       };
31148     }
31149   }
31150 }
31151
31152
31153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31154   int jresult ;
31155   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31156   Dali::ColorMode result;
31157
31158   arg1 = (Dali::Actor *)jarg1;
31159   {
31160     try {
31161       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31162     } catch (std::out_of_range& e) {
31163       {
31164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31165       };
31166     } catch (std::exception& e) {
31167       {
31168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31169       };
31170     } catch (...) {
31171       {
31172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31173       };
31174     }
31175   }
31176   jresult = (int)result;
31177   return jresult;
31178 }
31179
31180
31181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31182   void * jresult ;
31183   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31184   Dali::Vector4 result;
31185
31186   arg1 = (Dali::Actor *)jarg1;
31187   {
31188     try {
31189       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31190     } catch (std::out_of_range& e) {
31191       {
31192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31193       };
31194     } catch (std::exception& e) {
31195       {
31196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31197       };
31198     } catch (...) {
31199       {
31200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31201       };
31202     }
31203   }
31204   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31205   return jresult;
31206 }
31207
31208
31209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31210   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31211   Dali::DrawMode::Type arg2 ;
31212
31213   arg1 = (Dali::Actor *)jarg1;
31214   arg2 = (Dali::DrawMode::Type)jarg2;
31215   {
31216     try {
31217       (arg1)->SetDrawMode(arg2);
31218     } catch (std::out_of_range& e) {
31219       {
31220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31221       };
31222     } catch (std::exception& e) {
31223       {
31224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31225       };
31226     } catch (...) {
31227       {
31228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31229       };
31230     }
31231   }
31232 }
31233
31234
31235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31236   int jresult ;
31237   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31238   Dali::DrawMode::Type result;
31239
31240   arg1 = (Dali::Actor *)jarg1;
31241   {
31242     try {
31243       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31244     } catch (std::out_of_range& e) {
31245       {
31246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31247       };
31248     } catch (std::exception& e) {
31249       {
31250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31251       };
31252     } catch (...) {
31253       {
31254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31255       };
31256     }
31257   }
31258   jresult = (int)result;
31259   return jresult;
31260 }
31261
31262
31263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31264   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31265   bool arg2 ;
31266
31267   arg1 = (Dali::Actor *)jarg1;
31268   arg2 = jarg2 ? true : false;
31269   {
31270     try {
31271       (arg1)->SetSensitive(arg2);
31272     } catch (std::out_of_range& e) {
31273       {
31274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31275       };
31276     } catch (std::exception& e) {
31277       {
31278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31279       };
31280     } catch (...) {
31281       {
31282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31283       };
31284     }
31285   }
31286 }
31287
31288
31289 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31290   unsigned int jresult ;
31291   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31292   bool result;
31293
31294   arg1 = (Dali::Actor *)jarg1;
31295   {
31296     try {
31297       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31298     } catch (std::out_of_range& e) {
31299       {
31300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31301       };
31302     } catch (std::exception& e) {
31303       {
31304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31305       };
31306     } catch (...) {
31307       {
31308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31309       };
31310     }
31311   }
31312   jresult = result;
31313   return jresult;
31314 }
31315
31316
31317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31318   unsigned int jresult ;
31319   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31320   float *arg2 = 0 ;
31321   float *arg3 = 0 ;
31322   float arg4 ;
31323   float arg5 ;
31324   bool result;
31325
31326   arg1 = (Dali::Actor *)jarg1;
31327   arg2 = (float *)jarg2;
31328   arg3 = (float *)jarg3;
31329   arg4 = (float)jarg4;
31330   arg5 = (float)jarg5;
31331   {
31332     try {
31333       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31334     } catch (std::out_of_range& e) {
31335       {
31336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31337       };
31338     } catch (std::exception& e) {
31339       {
31340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31341       };
31342     } catch (...) {
31343       {
31344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31345       };
31346     }
31347   }
31348   jresult = result;
31349   return jresult;
31350 }
31351
31352
31353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31354   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31355   bool arg2 ;
31356
31357   arg1 = (Dali::Actor *)jarg1;
31358   arg2 = jarg2 ? true : false;
31359   {
31360     try {
31361       (arg1)->SetLeaveRequired(arg2);
31362     } catch (std::out_of_range& e) {
31363       {
31364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31365       };
31366     } catch (std::exception& e) {
31367       {
31368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31369       };
31370     } catch (...) {
31371       {
31372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31373       };
31374     }
31375   }
31376 }
31377
31378
31379 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31380   unsigned int jresult ;
31381   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31382   bool result;
31383
31384   arg1 = (Dali::Actor *)jarg1;
31385   {
31386     try {
31387       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31388     } catch (std::out_of_range& e) {
31389       {
31390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31391       };
31392     } catch (std::exception& e) {
31393       {
31394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31395       };
31396     } catch (...) {
31397       {
31398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31399       };
31400     }
31401   }
31402   jresult = result;
31403   return jresult;
31404 }
31405
31406
31407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31408   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31409   bool arg2 ;
31410
31411   arg1 = (Dali::Actor *)jarg1;
31412   arg2 = jarg2 ? true : false;
31413   {
31414     try {
31415       (arg1)->SetKeyboardFocusable(arg2);
31416     } catch (std::out_of_range& e) {
31417       {
31418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31419       };
31420     } catch (std::exception& e) {
31421       {
31422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31423       };
31424     } catch (...) {
31425       {
31426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31427       };
31428     }
31429   }
31430 }
31431
31432
31433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31434   unsigned int jresult ;
31435   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31436   bool result;
31437
31438   arg1 = (Dali::Actor *)jarg1;
31439   {
31440     try {
31441       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31442     } catch (std::out_of_range& e) {
31443       {
31444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31445       };
31446     } catch (std::exception& e) {
31447       {
31448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31449       };
31450     } catch (...) {
31451       {
31452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31453       };
31454     }
31455   }
31456   jresult = result;
31457   return jresult;
31458 }
31459
31460
31461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31462   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31463   Dali::ResizePolicy::Type arg2 ;
31464   Dali::Dimension::Type arg3 ;
31465
31466   arg1 = (Dali::Actor *)jarg1;
31467   arg2 = (Dali::ResizePolicy::Type)jarg2;
31468   arg3 = (Dali::Dimension::Type)jarg3;
31469   {
31470     try {
31471       (arg1)->SetResizePolicy(arg2,arg3);
31472     } catch (std::out_of_range& e) {
31473       {
31474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31475       };
31476     } catch (std::exception& e) {
31477       {
31478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31479       };
31480     } catch (...) {
31481       {
31482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31483       };
31484     }
31485   }
31486 }
31487
31488
31489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31490   int jresult ;
31491   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31492   Dali::Dimension::Type arg2 ;
31493   Dali::ResizePolicy::Type result;
31494
31495   arg1 = (Dali::Actor *)jarg1;
31496   arg2 = (Dali::Dimension::Type)jarg2;
31497   {
31498     try {
31499       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31500     } catch (std::out_of_range& e) {
31501       {
31502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31503       };
31504     } catch (std::exception& e) {
31505       {
31506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31507       };
31508     } catch (...) {
31509       {
31510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31511       };
31512     }
31513   }
31514   jresult = (int)result;
31515   return jresult;
31516 }
31517
31518
31519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31520   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31521   Dali::SizeScalePolicy::Type arg2 ;
31522
31523   arg1 = (Dali::Actor *)jarg1;
31524   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31525   {
31526     try {
31527       (arg1)->SetSizeScalePolicy(arg2);
31528     } catch (std::out_of_range& e) {
31529       {
31530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31531       };
31532     } catch (std::exception& e) {
31533       {
31534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31535       };
31536     } catch (...) {
31537       {
31538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31539       };
31540     }
31541   }
31542 }
31543
31544
31545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31546   int jresult ;
31547   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31548   Dali::SizeScalePolicy::Type result;
31549
31550   arg1 = (Dali::Actor *)jarg1;
31551   {
31552     try {
31553       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31554     } catch (std::out_of_range& e) {
31555       {
31556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31557       };
31558     } catch (std::exception& e) {
31559       {
31560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31561       };
31562     } catch (...) {
31563       {
31564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31565       };
31566     }
31567   }
31568   jresult = (int)result;
31569   return jresult;
31570 }
31571
31572
31573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31574   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31575   Dali::Vector3 *arg2 = 0 ;
31576
31577   arg1 = (Dali::Actor *)jarg1;
31578   arg2 = (Dali::Vector3 *)jarg2;
31579   if (!arg2) {
31580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31581     return ;
31582   }
31583   {
31584     try {
31585       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31586     } catch (std::out_of_range& e) {
31587       {
31588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31589       };
31590     } catch (std::exception& e) {
31591       {
31592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31593       };
31594     } catch (...) {
31595       {
31596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31597       };
31598     }
31599   }
31600 }
31601
31602
31603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31604   void * jresult ;
31605   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31606   Dali::Vector3 result;
31607
31608   arg1 = (Dali::Actor *)jarg1;
31609   {
31610     try {
31611       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31612     } catch (std::out_of_range& e) {
31613       {
31614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31615       };
31616     } catch (std::exception& e) {
31617       {
31618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31619       };
31620     } catch (...) {
31621       {
31622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31623       };
31624     }
31625   }
31626   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31627   return jresult;
31628 }
31629
31630
31631 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31632   float jresult ;
31633   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31634   float arg2 ;
31635   float result;
31636
31637   arg1 = (Dali::Actor *)jarg1;
31638   arg2 = (float)jarg2;
31639   {
31640     try {
31641       result = (float)(arg1)->GetHeightForWidth(arg2);
31642     } catch (std::out_of_range& e) {
31643       {
31644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31645       };
31646     } catch (std::exception& e) {
31647       {
31648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31649       };
31650     } catch (...) {
31651       {
31652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31653       };
31654     }
31655   }
31656   jresult = result;
31657   return jresult;
31658 }
31659
31660
31661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31662   float jresult ;
31663   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31664   float arg2 ;
31665   float result;
31666
31667   arg1 = (Dali::Actor *)jarg1;
31668   arg2 = (float)jarg2;
31669   {
31670     try {
31671       result = (float)(arg1)->GetWidthForHeight(arg2);
31672     } catch (std::out_of_range& e) {
31673       {
31674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31675       };
31676     } catch (std::exception& e) {
31677       {
31678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31679       };
31680     } catch (...) {
31681       {
31682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31683       };
31684     }
31685   }
31686   jresult = result;
31687   return jresult;
31688 }
31689
31690
31691 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31692   float jresult ;
31693   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31694   Dali::Dimension::Type arg2 ;
31695   float result;
31696
31697   arg1 = (Dali::Actor *)jarg1;
31698   arg2 = (Dali::Dimension::Type)jarg2;
31699   {
31700     try {
31701       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31702     } catch (std::out_of_range& e) {
31703       {
31704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31705       };
31706     } catch (std::exception& e) {
31707       {
31708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31709       };
31710     } catch (...) {
31711       {
31712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31713       };
31714     }
31715   }
31716   jresult = result;
31717   return jresult;
31718 }
31719
31720
31721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31722   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31723   Dali::Padding *arg2 = 0 ;
31724
31725   arg1 = (Dali::Actor *)jarg1;
31726   arg2 = (Dali::Padding *)jarg2;
31727   if (!arg2) {
31728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31729     return ;
31730   }
31731   {
31732     try {
31733       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31734     } catch (std::out_of_range& e) {
31735       {
31736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31737       };
31738     } catch (std::exception& e) {
31739       {
31740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31741       };
31742     } catch (...) {
31743       {
31744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31745       };
31746     }
31747   }
31748 }
31749
31750
31751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
31752   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31753   Dali::Padding *arg2 = 0 ;
31754
31755   arg1 = (Dali::Actor *)jarg1;
31756   arg2 = (Dali::Padding *)jarg2;
31757   if (!arg2) {
31758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31759     return ;
31760   }
31761   {
31762     try {
31763       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
31764     } catch (std::out_of_range& e) {
31765       {
31766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31767       };
31768     } catch (std::exception& e) {
31769       {
31770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31771       };
31772     } catch (...) {
31773       {
31774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31775       };
31776     }
31777   }
31778 }
31779
31780
31781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
31782   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31783   Dali::Vector2 *arg2 = 0 ;
31784
31785   arg1 = (Dali::Actor *)jarg1;
31786   arg2 = (Dali::Vector2 *)jarg2;
31787   if (!arg2) {
31788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31789     return ;
31790   }
31791   {
31792     try {
31793       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31794     } catch (std::out_of_range& e) {
31795       {
31796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31797       };
31798     } catch (std::exception& e) {
31799       {
31800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31801       };
31802     } catch (...) {
31803       {
31804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31805       };
31806     }
31807   }
31808 }
31809
31810
31811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
31812   void * jresult ;
31813   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31814   Dali::Vector2 result;
31815
31816   arg1 = (Dali::Actor *)jarg1;
31817   {
31818     try {
31819       result = (arg1)->GetMinimumSize();
31820     } catch (std::out_of_range& e) {
31821       {
31822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31823       };
31824     } catch (std::exception& e) {
31825       {
31826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31827       };
31828     } catch (...) {
31829       {
31830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31831       };
31832     }
31833   }
31834   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31835   return jresult;
31836 }
31837
31838
31839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
31840   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31841   Dali::Vector2 *arg2 = 0 ;
31842
31843   arg1 = (Dali::Actor *)jarg1;
31844   arg2 = (Dali::Vector2 *)jarg2;
31845   if (!arg2) {
31846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31847     return ;
31848   }
31849   {
31850     try {
31851       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
31852     } catch (std::out_of_range& e) {
31853       {
31854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31855       };
31856     } catch (std::exception& e) {
31857       {
31858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31859       };
31860     } catch (...) {
31861       {
31862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31863       };
31864     }
31865   }
31866 }
31867
31868
31869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
31870   void * jresult ;
31871   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31872   Dali::Vector2 result;
31873
31874   arg1 = (Dali::Actor *)jarg1;
31875   {
31876     try {
31877       result = (arg1)->GetMaximumSize();
31878     } catch (std::out_of_range& e) {
31879       {
31880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31881       };
31882     } catch (std::exception& e) {
31883       {
31884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31885       };
31886     } catch (...) {
31887       {
31888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31889       };
31890     }
31891   }
31892   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31893   return jresult;
31894 }
31895
31896
31897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
31898   int jresult ;
31899   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31900   int result;
31901
31902   arg1 = (Dali::Actor *)jarg1;
31903   {
31904     try {
31905       result = (int)(arg1)->GetHierarchyDepth();
31906     } catch (std::out_of_range& e) {
31907       {
31908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31909       };
31910     } catch (std::exception& e) {
31911       {
31912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31913       };
31914     } catch (...) {
31915       {
31916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31917       };
31918     }
31919   }
31920   jresult = result;
31921   return jresult;
31922 }
31923
31924
31925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
31926   unsigned int jresult ;
31927   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31928   Dali::Renderer *arg2 = 0 ;
31929   unsigned int result;
31930
31931   arg1 = (Dali::Actor *)jarg1;
31932   arg2 = (Dali::Renderer *)jarg2;
31933   if (!arg2) {
31934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
31935     return 0;
31936   }
31937   {
31938     try {
31939       result = (unsigned int)(arg1)->AddRenderer(*arg2);
31940     } catch (std::out_of_range& e) {
31941       {
31942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31943       };
31944     } catch (std::exception& e) {
31945       {
31946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31947       };
31948     } catch (...) {
31949       {
31950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31951       };
31952     }
31953   }
31954   jresult = result;
31955   return jresult;
31956 }
31957
31958
31959 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
31960   unsigned int jresult ;
31961   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31962   unsigned int result;
31963
31964   arg1 = (Dali::Actor *)jarg1;
31965   {
31966     try {
31967       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
31968     } catch (std::out_of_range& e) {
31969       {
31970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31971       };
31972     } catch (std::exception& e) {
31973       {
31974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31975       };
31976     } catch (...) {
31977       {
31978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31979       };
31980     }
31981   }
31982   jresult = result;
31983   return jresult;
31984 }
31985
31986
31987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
31988   void * jresult ;
31989   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31990   unsigned int arg2 ;
31991   Dali::Renderer result;
31992
31993   arg1 = (Dali::Actor *)jarg1;
31994   arg2 = (unsigned int)jarg2;
31995   {
31996     try {
31997       result = (arg1)->GetRendererAt(arg2);
31998     } catch (std::out_of_range& e) {
31999       {
32000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32001       };
32002     } catch (std::exception& e) {
32003       {
32004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32005       };
32006     } catch (...) {
32007       {
32008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32009       };
32010     }
32011   }
32012   jresult = new Dali::Renderer((const Dali::Renderer &)result);
32013   return jresult;
32014 }
32015
32016
32017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
32018   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32019   Dali::Renderer *arg2 = 0 ;
32020
32021   arg1 = (Dali::Actor *)jarg1;
32022   arg2 = (Dali::Renderer *)jarg2;
32023   if (!arg2) {
32024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32025     return ;
32026   }
32027   {
32028     try {
32029       (arg1)->RemoveRenderer(*arg2);
32030     } catch (std::out_of_range& e) {
32031       {
32032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32033       };
32034     } catch (std::exception& e) {
32035       {
32036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32037       };
32038     } catch (...) {
32039       {
32040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32041       };
32042     }
32043   }
32044 }
32045
32046
32047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
32048   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32049   unsigned int arg2 ;
32050
32051   arg1 = (Dali::Actor *)jarg1;
32052   arg2 = (unsigned int)jarg2;
32053   {
32054     try {
32055       (arg1)->RemoveRenderer(arg2);
32056     } catch (std::out_of_range& e) {
32057       {
32058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32059       };
32060     } catch (std::exception& e) {
32061       {
32062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32063       };
32064     } catch (...) {
32065       {
32066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32067       };
32068     }
32069   }
32070 }
32071
32072
32073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
32074   void * jresult ;
32075   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32076   Dali::Actor::TouchSignalType *result = 0 ;
32077
32078   arg1 = (Dali::Actor *)jarg1;
32079   {
32080     try {
32081       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
32082     } catch (std::out_of_range& e) {
32083       {
32084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32085       };
32086     } catch (std::exception& e) {
32087       {
32088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32089       };
32090     } catch (...) {
32091       {
32092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32093       };
32094     }
32095   }
32096   jresult = (void *)result;
32097   return jresult;
32098 }
32099
32100
32101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
32102   void * jresult ;
32103   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32104   Dali::Actor::TouchDataSignalType *result = 0 ;
32105
32106   arg1 = (Dali::Actor *)jarg1;
32107   {
32108     try {
32109       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
32110     } catch (std::out_of_range& e) {
32111       {
32112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32113       };
32114     } catch (std::exception& e) {
32115       {
32116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32117       };
32118     } catch (...) {
32119       {
32120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32121       };
32122     }
32123   }
32124   jresult = (void *)result;
32125   return jresult;
32126 }
32127
32128
32129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32130   void * jresult ;
32131   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32132   Dali::Actor::HoverSignalType *result = 0 ;
32133
32134   arg1 = (Dali::Actor *)jarg1;
32135   {
32136     try {
32137       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32138     } catch (std::out_of_range& e) {
32139       {
32140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32141       };
32142     } catch (std::exception& e) {
32143       {
32144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32145       };
32146     } catch (...) {
32147       {
32148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32149       };
32150     }
32151   }
32152   jresult = (void *)result;
32153   return jresult;
32154 }
32155
32156
32157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32158   void * jresult ;
32159   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32160   Dali::Actor::WheelEventSignalType *result = 0 ;
32161
32162   arg1 = (Dali::Actor *)jarg1;
32163   {
32164     try {
32165       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32166     } catch (std::out_of_range& e) {
32167       {
32168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32169       };
32170     } catch (std::exception& e) {
32171       {
32172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32173       };
32174     } catch (...) {
32175       {
32176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32177       };
32178     }
32179   }
32180   jresult = (void *)result;
32181   return jresult;
32182 }
32183
32184
32185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32186   void * jresult ;
32187   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32188   Dali::Actor::OnStageSignalType *result = 0 ;
32189
32190   arg1 = (Dali::Actor *)jarg1;
32191   {
32192     try {
32193       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32194     } catch (std::out_of_range& e) {
32195       {
32196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32197       };
32198     } catch (std::exception& e) {
32199       {
32200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32201       };
32202     } catch (...) {
32203       {
32204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32205       };
32206     }
32207   }
32208   jresult = (void *)result;
32209   return jresult;
32210 }
32211
32212
32213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32214   void * jresult ;
32215   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32216   Dali::Actor::OffStageSignalType *result = 0 ;
32217
32218   arg1 = (Dali::Actor *)jarg1;
32219   {
32220     try {
32221       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32222     } catch (std::out_of_range& e) {
32223       {
32224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32225       };
32226     } catch (std::exception& e) {
32227       {
32228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32229       };
32230     } catch (...) {
32231       {
32232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32233       };
32234     }
32235   }
32236   jresult = (void *)result;
32237   return jresult;
32238 }
32239
32240
32241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32242   void * jresult ;
32243   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32244   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32245
32246   arg1 = (Dali::Actor *)jarg1;
32247   {
32248     try {
32249       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32250     } catch (std::out_of_range& e) {
32251       {
32252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32253       };
32254     } catch (std::exception& e) {
32255       {
32256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32257       };
32258     } catch (...) {
32259       {
32260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32261       };
32262     }
32263   }
32264   jresult = (void *)result;
32265   return jresult;
32266 }
32267
32268
32269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32270   Dali::Actor *arg1 = 0 ;
32271
32272   arg1 = (Dali::Actor *)jarg1;
32273   if (!arg1) {
32274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32275     return ;
32276   }
32277   {
32278     try {
32279       Dali::UnparentAndReset(*arg1);
32280     } catch (std::out_of_range& e) {
32281       {
32282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32283       };
32284     } catch (std::exception& e) {
32285       {
32286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32287       };
32288     } catch (...) {
32289       {
32290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32291       };
32292     }
32293   }
32294 }
32295
32296
32297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32298   Dali::Actor arg1 ;
32299   Dali::Actor *argp1 ;
32300
32301   argp1 = (Dali::Actor *)jarg1;
32302   if (!argp1) {
32303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32304     return ;
32305   }
32306   arg1 = *argp1;
32307   {
32308     try {
32309       Dali::DevelActor::Raise(arg1);
32310     } catch (std::out_of_range& e) {
32311       {
32312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32313       };
32314     } catch (std::exception& e) {
32315       {
32316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32317       };
32318     } catch (...) {
32319       {
32320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32321       };
32322     }
32323   }
32324 }
32325
32326
32327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32328   Dali::Actor arg1 ;
32329   Dali::Actor *argp1 ;
32330
32331   argp1 = (Dali::Actor *)jarg1;
32332   if (!argp1) {
32333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32334     return ;
32335   }
32336   arg1 = *argp1;
32337   {
32338     try {
32339       Dali::DevelActor::Lower(arg1);
32340     } catch (std::out_of_range& e) {
32341       {
32342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32343       };
32344     } catch (std::exception& e) {
32345       {
32346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32347       };
32348     } catch (...) {
32349       {
32350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32351       };
32352     }
32353   }
32354 }
32355
32356
32357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32358   Dali::Actor arg1 ;
32359   Dali::Actor *argp1 ;
32360
32361   argp1 = (Dali::Actor *)jarg1;
32362   if (!argp1) {
32363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32364     return ;
32365   }
32366   arg1 = *argp1;
32367   {
32368     try {
32369       Dali::DevelActor::RaiseToTop(arg1);
32370     } catch (std::out_of_range& e) {
32371       {
32372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32373       };
32374     } catch (std::exception& e) {
32375       {
32376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32377       };
32378     } catch (...) {
32379       {
32380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32381       };
32382     }
32383   }
32384 }
32385
32386
32387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32388   Dali::Actor arg1 ;
32389   Dali::Actor *argp1 ;
32390
32391   argp1 = (Dali::Actor *)jarg1;
32392   if (!argp1) {
32393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32394     return ;
32395   }
32396   arg1 = *argp1;
32397   {
32398     try {
32399       Dali::DevelActor::LowerToBottom(arg1);
32400     } catch (std::out_of_range& e) {
32401       {
32402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32403       };
32404     } catch (std::exception& e) {
32405       {
32406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32407       };
32408     } catch (...) {
32409       {
32410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32411       };
32412     }
32413   }
32414 }
32415
32416
32417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32418   Dali::Actor arg1 ;
32419   Dali::Actor arg2 ;
32420   Dali::Actor *argp1 ;
32421   Dali::Actor *argp2 ;
32422
32423   argp1 = (Dali::Actor *)jarg1;
32424   if (!argp1) {
32425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32426     return ;
32427   }
32428   arg1 = *argp1;
32429   argp2 = (Dali::Actor *)jarg2;
32430   if (!argp2) {
32431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32432     return ;
32433   }
32434   arg2 = *argp2;
32435   {
32436     try {
32437       Dali::DevelActor::RaiseAbove(arg1,arg2);
32438     } catch (std::out_of_range& e) {
32439       {
32440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32441       };
32442     } catch (std::exception& e) {
32443       {
32444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32445       };
32446     } catch (...) {
32447       {
32448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32449       };
32450     }
32451   }
32452 }
32453
32454
32455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32456   Dali::Actor arg1 ;
32457   Dali::Actor arg2 ;
32458   Dali::Actor *argp1 ;
32459   Dali::Actor *argp2 ;
32460
32461   argp1 = (Dali::Actor *)jarg1;
32462   if (!argp1) {
32463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32464     return ;
32465   }
32466   arg1 = *argp1;
32467   argp2 = (Dali::Actor *)jarg2;
32468   if (!argp2) {
32469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32470     return ;
32471   }
32472   arg2 = *argp2;
32473   {
32474     try {
32475       Dali::DevelActor::LowerBelow(arg1,arg2);
32476     } catch (std::out_of_range& e) {
32477       {
32478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32479       };
32480     } catch (std::exception& e) {
32481       {
32482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32483       };
32484     } catch (...) {
32485       {
32486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32487       };
32488     }
32489   }
32490 }
32491
32492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32493   void * jresult ;
32494   Dali::Actor arg1 ;
32495   Dali::Actor *argp1 ;
32496   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32497
32498   argp1 = (Dali::Actor *)jarg1;
32499   if (!argp1) {
32500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32501     return 0;
32502   }
32503   arg1 = *argp1;
32504   {
32505     try {
32506       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32507     } catch (std::out_of_range& e) {
32508       {
32509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32510       };
32511     } catch (std::exception& e) {
32512       {
32513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32514       };
32515     } catch (...) {
32516       {
32517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32518       };
32519     }
32520   }
32521   jresult = (void *)result;
32522   return jresult;
32523 }
32524
32525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32526   int jresult ;
32527   int result;
32528
32529   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32530   jresult = (int)result;
32531   return jresult;
32532 }
32533
32534
32535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32536   int jresult ;
32537   int result;
32538
32539   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32540   jresult = (int)result;
32541   return jresult;
32542 }
32543
32544
32545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32546   int jresult ;
32547   int result;
32548
32549   result = (int)Dali::Layer::Property::BEHAVIOR;
32550   jresult = (int)result;
32551   return jresult;
32552 }
32553
32554
32555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32556   void * jresult ;
32557   Dali::Layer::Property *result = 0 ;
32558
32559   {
32560     try {
32561       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32562     } catch (std::out_of_range& e) {
32563       {
32564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32565       };
32566     } catch (std::exception& e) {
32567       {
32568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32569       };
32570     } catch (...) {
32571       {
32572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32573       };
32574     }
32575   }
32576   jresult = (void *)result;
32577   return jresult;
32578 }
32579
32580
32581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32582   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32583
32584   arg1 = (Dali::Layer::Property *)jarg1;
32585   {
32586     try {
32587       delete arg1;
32588     } catch (std::out_of_range& e) {
32589       {
32590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32591       };
32592     } catch (std::exception& e) {
32593       {
32594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32595       };
32596     } catch (...) {
32597       {
32598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32599       };
32600     }
32601   }
32602 }
32603
32604
32605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32606   void * jresult ;
32607   Dali::Layer *result = 0 ;
32608
32609   {
32610     try {
32611       result = (Dali::Layer *)new Dali::Layer();
32612     } catch (std::out_of_range& e) {
32613       {
32614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32615       };
32616     } catch (std::exception& e) {
32617       {
32618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32619       };
32620     } catch (...) {
32621       {
32622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32623       };
32624     }
32625   }
32626   jresult = (void *)result;
32627   return jresult;
32628 }
32629
32630
32631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32632   void * jresult ;
32633   Dali::Layer result;
32634
32635   {
32636     try {
32637       result = Dali::Layer::New();
32638     } catch (std::out_of_range& e) {
32639       {
32640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32641       };
32642     } catch (std::exception& e) {
32643       {
32644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32645       };
32646     } catch (...) {
32647       {
32648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32649       };
32650     }
32651   }
32652   jresult = new Dali::Layer((const Dali::Layer &)result);
32653   return jresult;
32654 }
32655
32656
32657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32658   void * jresult ;
32659   Dali::BaseHandle arg1 ;
32660   Dali::BaseHandle *argp1 ;
32661   Dali::Layer result;
32662
32663   argp1 = (Dali::BaseHandle *)jarg1;
32664   if (!argp1) {
32665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32666     return 0;
32667   }
32668   arg1 = *argp1;
32669   {
32670     try {
32671       result = Dali::Layer::DownCast(arg1);
32672     } catch (std::out_of_range& e) {
32673       {
32674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32675       };
32676     } catch (std::exception& e) {
32677       {
32678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32679       };
32680     } catch (...) {
32681       {
32682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32683       };
32684     }
32685   }
32686   jresult = new Dali::Layer((const Dali::Layer &)result);
32687   return jresult;
32688 }
32689
32690
32691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32692   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32693
32694   arg1 = (Dali::Layer *)jarg1;
32695   {
32696     try {
32697       delete arg1;
32698     } catch (std::out_of_range& e) {
32699       {
32700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32701       };
32702     } catch (std::exception& e) {
32703       {
32704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32705       };
32706     } catch (...) {
32707       {
32708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32709       };
32710     }
32711   }
32712 }
32713
32714
32715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32716   void * jresult ;
32717   Dali::Layer *arg1 = 0 ;
32718   Dali::Layer *result = 0 ;
32719
32720   arg1 = (Dali::Layer *)jarg1;
32721   if (!arg1) {
32722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32723     return 0;
32724   }
32725   {
32726     try {
32727       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32728     } catch (std::out_of_range& e) {
32729       {
32730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32731       };
32732     } catch (std::exception& e) {
32733       {
32734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32735       };
32736     } catch (...) {
32737       {
32738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32739       };
32740     }
32741   }
32742   jresult = (void *)result;
32743   return jresult;
32744 }
32745
32746
32747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32748   void * jresult ;
32749   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32750   Dali::Layer *arg2 = 0 ;
32751   Dali::Layer *result = 0 ;
32752
32753   arg1 = (Dali::Layer *)jarg1;
32754   arg2 = (Dali::Layer *)jarg2;
32755   if (!arg2) {
32756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32757     return 0;
32758   }
32759   {
32760     try {
32761       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32762     } catch (std::out_of_range& e) {
32763       {
32764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32765       };
32766     } catch (std::exception& e) {
32767       {
32768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32769       };
32770     } catch (...) {
32771       {
32772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32773       };
32774     }
32775   }
32776   jresult = (void *)result;
32777   return jresult;
32778 }
32779
32780
32781 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32782   unsigned int jresult ;
32783   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32784   unsigned int result;
32785
32786   arg1 = (Dali::Layer *)jarg1;
32787   {
32788     try {
32789       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32790     } catch (std::out_of_range& e) {
32791       {
32792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32793       };
32794     } catch (std::exception& e) {
32795       {
32796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32797       };
32798     } catch (...) {
32799       {
32800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32801       };
32802     }
32803   }
32804   jresult = result;
32805   return jresult;
32806 }
32807
32808
32809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32810   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32811
32812   arg1 = (Dali::Layer *)jarg1;
32813   {
32814     try {
32815       (arg1)->Raise();
32816     } catch (std::out_of_range& e) {
32817       {
32818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32819       };
32820     } catch (std::exception& e) {
32821       {
32822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32823       };
32824     } catch (...) {
32825       {
32826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32827       };
32828     }
32829   }
32830 }
32831
32832
32833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32834   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32835
32836   arg1 = (Dali::Layer *)jarg1;
32837   {
32838     try {
32839       (arg1)->Lower();
32840     } catch (std::out_of_range& e) {
32841       {
32842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32843       };
32844     } catch (std::exception& e) {
32845       {
32846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32847       };
32848     } catch (...) {
32849       {
32850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32851       };
32852     }
32853   }
32854 }
32855
32856
32857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32858   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32859   Dali::Layer arg2 ;
32860   Dali::Layer *argp2 ;
32861
32862   arg1 = (Dali::Layer *)jarg1;
32863   argp2 = (Dali::Layer *)jarg2;
32864   if (!argp2) {
32865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32866     return ;
32867   }
32868   arg2 = *argp2;
32869   {
32870     try {
32871       (arg1)->RaiseAbove(arg2);
32872     } catch (std::out_of_range& e) {
32873       {
32874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32875       };
32876     } catch (std::exception& e) {
32877       {
32878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32879       };
32880     } catch (...) {
32881       {
32882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32883       };
32884     }
32885   }
32886 }
32887
32888
32889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32890   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32891   Dali::Layer arg2 ;
32892   Dali::Layer *argp2 ;
32893
32894   arg1 = (Dali::Layer *)jarg1;
32895   argp2 = (Dali::Layer *)jarg2;
32896   if (!argp2) {
32897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32898     return ;
32899   }
32900   arg2 = *argp2;
32901   {
32902     try {
32903       (arg1)->LowerBelow(arg2);
32904     } catch (std::out_of_range& e) {
32905       {
32906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32907       };
32908     } catch (std::exception& e) {
32909       {
32910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32911       };
32912     } catch (...) {
32913       {
32914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32915       };
32916     }
32917   }
32918 }
32919
32920
32921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32922   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32923
32924   arg1 = (Dali::Layer *)jarg1;
32925   {
32926     try {
32927       (arg1)->RaiseToTop();
32928     } catch (std::out_of_range& e) {
32929       {
32930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32931       };
32932     } catch (std::exception& e) {
32933       {
32934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32935       };
32936     } catch (...) {
32937       {
32938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32939       };
32940     }
32941   }
32942 }
32943
32944
32945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32946   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32947
32948   arg1 = (Dali::Layer *)jarg1;
32949   {
32950     try {
32951       (arg1)->LowerToBottom();
32952     } catch (std::out_of_range& e) {
32953       {
32954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32955       };
32956     } catch (std::exception& e) {
32957       {
32958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32959       };
32960     } catch (...) {
32961       {
32962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32963       };
32964     }
32965   }
32966 }
32967
32968
32969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32970   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32971   Dali::Layer arg2 ;
32972   Dali::Layer *argp2 ;
32973
32974   arg1 = (Dali::Layer *)jarg1;
32975   argp2 = (Dali::Layer *)jarg2;
32976   if (!argp2) {
32977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32978     return ;
32979   }
32980   arg2 = *argp2;
32981   {
32982     try {
32983       (arg1)->MoveAbove(arg2);
32984     } catch (std::out_of_range& e) {
32985       {
32986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32987       };
32988     } catch (std::exception& e) {
32989       {
32990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32991       };
32992     } catch (...) {
32993       {
32994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32995       };
32996     }
32997   }
32998 }
32999
33000
33001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
33002   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33003   Dali::Layer arg2 ;
33004   Dali::Layer *argp2 ;
33005
33006   arg1 = (Dali::Layer *)jarg1;
33007   argp2 = (Dali::Layer *)jarg2;
33008   if (!argp2) {
33009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
33010     return ;
33011   }
33012   arg2 = *argp2;
33013   {
33014     try {
33015       (arg1)->MoveBelow(arg2);
33016     } catch (std::out_of_range& e) {
33017       {
33018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33019       };
33020     } catch (std::exception& e) {
33021       {
33022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33023       };
33024     } catch (...) {
33025       {
33026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33027       };
33028     }
33029   }
33030 }
33031
33032
33033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
33034   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33035   Dali::Layer::Behavior arg2 ;
33036
33037   arg1 = (Dali::Layer *)jarg1;
33038   arg2 = (Dali::Layer::Behavior)jarg2;
33039   {
33040     try {
33041       (arg1)->SetBehavior(arg2);
33042     } catch (std::out_of_range& e) {
33043       {
33044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33045       };
33046     } catch (std::exception& e) {
33047       {
33048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33049       };
33050     } catch (...) {
33051       {
33052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33053       };
33054     }
33055   }
33056 }
33057
33058
33059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
33060   int jresult ;
33061   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33062   Dali::Layer::Behavior result;
33063
33064   arg1 = (Dali::Layer *)jarg1;
33065   {
33066     try {
33067       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
33068     } catch (std::out_of_range& e) {
33069       {
33070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33071       };
33072     } catch (std::exception& e) {
33073       {
33074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33075       };
33076     } catch (...) {
33077       {
33078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33079       };
33080     }
33081   }
33082   jresult = (int)result;
33083   return jresult;
33084 }
33085
33086
33087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
33088   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33089   bool arg2 ;
33090
33091   arg1 = (Dali::Layer *)jarg1;
33092   arg2 = jarg2 ? true : false;
33093   {
33094     try {
33095       (arg1)->SetClipping(arg2);
33096     } catch (std::out_of_range& e) {
33097       {
33098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33099       };
33100     } catch (std::exception& e) {
33101       {
33102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33103       };
33104     } catch (...) {
33105       {
33106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33107       };
33108     }
33109   }
33110 }
33111
33112
33113 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
33114   unsigned int jresult ;
33115   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33116   bool result;
33117
33118   arg1 = (Dali::Layer *)jarg1;
33119   {
33120     try {
33121       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
33122     } catch (std::out_of_range& e) {
33123       {
33124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33125       };
33126     } catch (std::exception& e) {
33127       {
33128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33129       };
33130     } catch (...) {
33131       {
33132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33133       };
33134     }
33135   }
33136   jresult = result;
33137   return jresult;
33138 }
33139
33140
33141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
33142   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33143   int arg2 ;
33144   int arg3 ;
33145   int arg4 ;
33146   int arg5 ;
33147
33148   arg1 = (Dali::Layer *)jarg1;
33149   arg2 = (int)jarg2;
33150   arg3 = (int)jarg3;
33151   arg4 = (int)jarg4;
33152   arg5 = (int)jarg5;
33153   {
33154     try {
33155       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
33156     } catch (std::out_of_range& e) {
33157       {
33158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33159       };
33160     } catch (std::exception& e) {
33161       {
33162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33163       };
33164     } catch (...) {
33165       {
33166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33167       };
33168     }
33169   }
33170 }
33171
33172
33173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33174   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33175   Dali::ClippingBox arg2 ;
33176   Dali::ClippingBox *argp2 ;
33177
33178   arg1 = (Dali::Layer *)jarg1;
33179   argp2 = (Dali::ClippingBox *)jarg2;
33180   if (!argp2) {
33181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33182     return ;
33183   }
33184   arg2 = *argp2;
33185   {
33186     try {
33187       (arg1)->SetClippingBox(arg2);
33188     } catch (std::out_of_range& e) {
33189       {
33190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33191       };
33192     } catch (std::exception& e) {
33193       {
33194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33195       };
33196     } catch (...) {
33197       {
33198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33199       };
33200     }
33201   }
33202 }
33203
33204
33205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33206   void * jresult ;
33207   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33208   Dali::ClippingBox result;
33209
33210   arg1 = (Dali::Layer *)jarg1;
33211   {
33212     try {
33213       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33214     } catch (std::out_of_range& e) {
33215       {
33216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33217       };
33218     } catch (std::exception& e) {
33219       {
33220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33221       };
33222     } catch (...) {
33223       {
33224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33225       };
33226     }
33227   }
33228   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33229   return jresult;
33230 }
33231
33232
33233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33234   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33235   bool arg2 ;
33236
33237   arg1 = (Dali::Layer *)jarg1;
33238   arg2 = jarg2 ? true : false;
33239   {
33240     try {
33241       (arg1)->SetDepthTestDisabled(arg2);
33242     } catch (std::out_of_range& e) {
33243       {
33244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33245       };
33246     } catch (std::exception& e) {
33247       {
33248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33249       };
33250     } catch (...) {
33251       {
33252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33253       };
33254     }
33255   }
33256 }
33257
33258
33259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33260   unsigned int jresult ;
33261   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33262   bool result;
33263
33264   arg1 = (Dali::Layer *)jarg1;
33265   {
33266     try {
33267       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33268     } catch (std::out_of_range& e) {
33269       {
33270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33271       };
33272     } catch (std::exception& e) {
33273       {
33274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33275       };
33276     } catch (...) {
33277       {
33278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33279       };
33280     }
33281   }
33282   jresult = result;
33283   return jresult;
33284 }
33285
33286
33287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33288   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33289   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33290
33291   arg1 = (Dali::Layer *)jarg1;
33292   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33293   {
33294     try {
33295       (arg1)->SetSortFunction(arg2);
33296     } catch (std::out_of_range& e) {
33297       {
33298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33299       };
33300     } catch (std::exception& e) {
33301       {
33302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33303       };
33304     } catch (...) {
33305       {
33306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33307       };
33308     }
33309   }
33310 }
33311
33312
33313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33314   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33315   bool arg2 ;
33316
33317   arg1 = (Dali::Layer *)jarg1;
33318   arg2 = jarg2 ? true : false;
33319   {
33320     try {
33321       (arg1)->SetTouchConsumed(arg2);
33322     } catch (std::out_of_range& e) {
33323       {
33324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33325       };
33326     } catch (std::exception& e) {
33327       {
33328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33329       };
33330     } catch (...) {
33331       {
33332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33333       };
33334     }
33335   }
33336 }
33337
33338
33339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33340   unsigned int jresult ;
33341   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33342   bool result;
33343
33344   arg1 = (Dali::Layer *)jarg1;
33345   {
33346     try {
33347       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33348     } catch (std::out_of_range& e) {
33349       {
33350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33351       };
33352     } catch (std::exception& e) {
33353       {
33354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33355       };
33356     } catch (...) {
33357       {
33358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33359       };
33360     }
33361   }
33362   jresult = result;
33363   return jresult;
33364 }
33365
33366
33367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33368   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33369   bool arg2 ;
33370
33371   arg1 = (Dali::Layer *)jarg1;
33372   arg2 = jarg2 ? true : false;
33373   {
33374     try {
33375       (arg1)->SetHoverConsumed(arg2);
33376     } catch (std::out_of_range& e) {
33377       {
33378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33379       };
33380     } catch (std::exception& e) {
33381       {
33382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33383       };
33384     } catch (...) {
33385       {
33386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33387       };
33388     }
33389   }
33390 }
33391
33392
33393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33394   unsigned int jresult ;
33395   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33396   bool result;
33397
33398   arg1 = (Dali::Layer *)jarg1;
33399   {
33400     try {
33401       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33402     } catch (std::out_of_range& e) {
33403       {
33404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33405       };
33406     } catch (std::exception& e) {
33407       {
33408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33409       };
33410     } catch (...) {
33411       {
33412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33413       };
33414     }
33415   }
33416   jresult = result;
33417   return jresult;
33418 }
33419
33420
33421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33422   void * jresult ;
33423   Dali::Vector4 *result = 0 ;
33424
33425   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33426   jresult = (void *)result;
33427   return jresult;
33428 }
33429
33430
33431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33432   void * jresult ;
33433   Dali::Vector4 *result = 0 ;
33434
33435   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33436   jresult = (void *)result;
33437   return jresult;
33438 }
33439
33440
33441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33442   void * jresult ;
33443   Dali::Stage *result = 0 ;
33444
33445   {
33446     try {
33447       result = (Dali::Stage *)new Dali::Stage();
33448     } catch (std::out_of_range& e) {
33449       {
33450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33451       };
33452     } catch (std::exception& e) {
33453       {
33454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33455       };
33456     } catch (...) {
33457       {
33458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33459       };
33460     }
33461   }
33462   jresult = (void *)result;
33463   return jresult;
33464 }
33465
33466
33467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33468   void * jresult ;
33469   Dali::Stage result;
33470
33471   {
33472     try {
33473       result = Dali::Stage::GetCurrent();
33474     } catch (std::out_of_range& e) {
33475       {
33476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33477       };
33478     } catch (std::exception& e) {
33479       {
33480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33481       };
33482     } catch (...) {
33483       {
33484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33485       };
33486     }
33487   }
33488   jresult = new Dali::Stage((const Dali::Stage &)result);
33489   return jresult;
33490 }
33491
33492
33493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33494   unsigned int jresult ;
33495   bool result;
33496
33497   {
33498     try {
33499       result = (bool)Dali::Stage::IsInstalled();
33500     } catch (std::out_of_range& e) {
33501       {
33502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33503       };
33504     } catch (std::exception& e) {
33505       {
33506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33507       };
33508     } catch (...) {
33509       {
33510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33511       };
33512     }
33513   }
33514   jresult = result;
33515   return jresult;
33516 }
33517
33518
33519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33520   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33521
33522   arg1 = (Dali::Stage *)jarg1;
33523   {
33524     try {
33525       delete arg1;
33526     } catch (std::out_of_range& e) {
33527       {
33528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33529       };
33530     } catch (std::exception& e) {
33531       {
33532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33533       };
33534     } catch (...) {
33535       {
33536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33537       };
33538     }
33539   }
33540 }
33541
33542
33543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33544   void * jresult ;
33545   Dali::Stage *arg1 = 0 ;
33546   Dali::Stage *result = 0 ;
33547
33548   arg1 = (Dali::Stage *)jarg1;
33549   if (!arg1) {
33550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33551     return 0;
33552   }
33553   {
33554     try {
33555       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33556     } catch (std::out_of_range& e) {
33557       {
33558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33559       };
33560     } catch (std::exception& e) {
33561       {
33562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33563       };
33564     } catch (...) {
33565       {
33566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33567       };
33568     }
33569   }
33570   jresult = (void *)result;
33571   return jresult;
33572 }
33573
33574
33575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33576   void * jresult ;
33577   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33578   Dali::Stage *arg2 = 0 ;
33579   Dali::Stage *result = 0 ;
33580
33581   arg1 = (Dali::Stage *)jarg1;
33582   arg2 = (Dali::Stage *)jarg2;
33583   if (!arg2) {
33584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33585     return 0;
33586   }
33587   {
33588     try {
33589       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33590     } catch (std::out_of_range& e) {
33591       {
33592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33593       };
33594     } catch (std::exception& e) {
33595       {
33596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33597       };
33598     } catch (...) {
33599       {
33600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33601       };
33602     }
33603   }
33604   jresult = (void *)result;
33605   return jresult;
33606 }
33607
33608
33609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33610   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33611   Dali::Actor *arg2 = 0 ;
33612
33613   arg1 = (Dali::Stage *)jarg1;
33614   arg2 = (Dali::Actor *)jarg2;
33615   if (!arg2) {
33616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33617     return ;
33618   }
33619   {
33620     try {
33621       (arg1)->Add(*arg2);
33622     } catch (std::out_of_range& e) {
33623       {
33624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33625       };
33626     } catch (std::exception& e) {
33627       {
33628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33629       };
33630     } catch (...) {
33631       {
33632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33633       };
33634     }
33635   }
33636 }
33637
33638
33639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33640   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33641   Dali::Actor *arg2 = 0 ;
33642
33643   arg1 = (Dali::Stage *)jarg1;
33644   arg2 = (Dali::Actor *)jarg2;
33645   if (!arg2) {
33646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33647     return ;
33648   }
33649   {
33650     try {
33651       (arg1)->Remove(*arg2);
33652     } catch (std::out_of_range& e) {
33653       {
33654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33655       };
33656     } catch (std::exception& e) {
33657       {
33658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33659       };
33660     } catch (...) {
33661       {
33662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33663       };
33664     }
33665   }
33666 }
33667
33668
33669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33670   void * jresult ;
33671   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33672   Dali::Vector2 result;
33673
33674   arg1 = (Dali::Stage *)jarg1;
33675   {
33676     try {
33677       result = ((Dali::Stage const *)arg1)->GetSize();
33678     } catch (std::out_of_range& e) {
33679       {
33680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33681       };
33682     } catch (std::exception& e) {
33683       {
33684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33685       };
33686     } catch (...) {
33687       {
33688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33689       };
33690     }
33691   }
33692   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33693   return jresult;
33694 }
33695
33696
33697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33698   void * jresult ;
33699   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33700   Dali::RenderTaskList result;
33701
33702   arg1 = (Dali::Stage *)jarg1;
33703   {
33704     try {
33705       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33706     } catch (std::out_of_range& e) {
33707       {
33708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33709       };
33710     } catch (std::exception& e) {
33711       {
33712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33713       };
33714     } catch (...) {
33715       {
33716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33717       };
33718     }
33719   }
33720   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33721   return jresult;
33722 }
33723
33724
33725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33726   unsigned int jresult ;
33727   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33728   unsigned int result;
33729
33730   arg1 = (Dali::Stage *)jarg1;
33731   {
33732     try {
33733       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33734     } catch (std::out_of_range& e) {
33735       {
33736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33737       };
33738     } catch (std::exception& e) {
33739       {
33740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33741       };
33742     } catch (...) {
33743       {
33744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33745       };
33746     }
33747   }
33748   jresult = result;
33749   return jresult;
33750 }
33751
33752
33753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33754   void * jresult ;
33755   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33756   unsigned int arg2 ;
33757   Dali::Layer result;
33758
33759   arg1 = (Dali::Stage *)jarg1;
33760   arg2 = (unsigned int)jarg2;
33761   {
33762     try {
33763       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33764     } catch (std::out_of_range& e) {
33765       {
33766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33767       };
33768     } catch (std::exception& e) {
33769       {
33770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33771       };
33772     } catch (...) {
33773       {
33774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33775       };
33776     }
33777   }
33778   jresult = new Dali::Layer((const Dali::Layer &)result);
33779   return jresult;
33780 }
33781
33782
33783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33784   void * jresult ;
33785   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33786   Dali::Layer result;
33787
33788   arg1 = (Dali::Stage *)jarg1;
33789   {
33790     try {
33791       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33792     } catch (std::out_of_range& e) {
33793       {
33794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33795       };
33796     } catch (std::exception& e) {
33797       {
33798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33799       };
33800     } catch (...) {
33801       {
33802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33803       };
33804     }
33805   }
33806   jresult = new Dali::Layer((const Dali::Layer &)result);
33807   return jresult;
33808 }
33809
33810
33811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33812   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33813   Dali::Vector4 arg2 ;
33814   Dali::Vector4 *argp2 ;
33815
33816   arg1 = (Dali::Stage *)jarg1;
33817   argp2 = (Dali::Vector4 *)jarg2;
33818   if (!argp2) {
33819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33820     return ;
33821   }
33822   arg2 = *argp2;
33823   {
33824     try {
33825       (arg1)->SetBackgroundColor(arg2);
33826     } catch (std::out_of_range& e) {
33827       {
33828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33829       };
33830     } catch (std::exception& e) {
33831       {
33832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33833       };
33834     } catch (...) {
33835       {
33836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33837       };
33838     }
33839   }
33840 }
33841
33842
33843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33844   void * jresult ;
33845   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33846   Dali::Vector4 result;
33847
33848   arg1 = (Dali::Stage *)jarg1;
33849   {
33850     try {
33851       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33852     } catch (std::out_of_range& e) {
33853       {
33854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33855       };
33856     } catch (std::exception& e) {
33857       {
33858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33859       };
33860     } catch (...) {
33861       {
33862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33863       };
33864     }
33865   }
33866   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33867   return jresult;
33868 }
33869
33870
33871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33872   void * jresult ;
33873   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33874   Dali::Vector2 result;
33875
33876   arg1 = (Dali::Stage *)jarg1;
33877   {
33878     try {
33879       result = ((Dali::Stage const *)arg1)->GetDpi();
33880     } catch (std::out_of_range& e) {
33881       {
33882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33883       };
33884     } catch (std::exception& e) {
33885       {
33886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33887       };
33888     } catch (...) {
33889       {
33890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33891       };
33892     }
33893   }
33894   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33895   return jresult;
33896 }
33897
33898
33899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33900   void * jresult ;
33901   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33902   Dali::ObjectRegistry result;
33903
33904   arg1 = (Dali::Stage *)jarg1;
33905   {
33906     try {
33907       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33908     } catch (std::out_of_range& e) {
33909       {
33910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33911       };
33912     } catch (std::exception& e) {
33913       {
33914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33915       };
33916     } catch (...) {
33917       {
33918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33919       };
33920     }
33921   }
33922   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33923   return jresult;
33924 }
33925
33926
33927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33928   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33929   float arg2 ;
33930
33931   arg1 = (Dali::Stage *)jarg1;
33932   arg2 = (float)jarg2;
33933   {
33934     try {
33935       (arg1)->KeepRendering(arg2);
33936     } catch (std::out_of_range& e) {
33937       {
33938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33939       };
33940     } catch (std::exception& e) {
33941       {
33942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33943       };
33944     } catch (...) {
33945       {
33946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33947       };
33948     }
33949   }
33950 }
33951
33952
33953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33954   void * jresult ;
33955   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33956   Dali::Stage::KeyEventSignalType *result = 0 ;
33957
33958   arg1 = (Dali::Stage *)jarg1;
33959   {
33960     try {
33961       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33962     } catch (std::out_of_range& e) {
33963       {
33964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33965       };
33966     } catch (std::exception& e) {
33967       {
33968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33969       };
33970     } catch (...) {
33971       {
33972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33973       };
33974     }
33975   }
33976   jresult = (void *)result;
33977   return jresult;
33978 }
33979
33980
33981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
33982   void * jresult ;
33983   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33984   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
33985
33986   arg1 = (Dali::Stage *)jarg1;
33987   {
33988     try {
33989       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
33990     } catch (std::out_of_range& e) {
33991       {
33992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33993       };
33994     } catch (std::exception& e) {
33995       {
33996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33997       };
33998     } catch (...) {
33999       {
34000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34001       };
34002     }
34003   }
34004   jresult = (void *)result;
34005   return jresult;
34006 }
34007
34008
34009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
34010   void * jresult ;
34011   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34012   Dali::Stage::TouchSignalType *result = 0 ;
34013
34014   arg1 = (Dali::Stage *)jarg1;
34015   {
34016     try {
34017       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
34018     } catch (std::out_of_range& e) {
34019       {
34020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34021       };
34022     } catch (std::exception& e) {
34023       {
34024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34025       };
34026     } catch (...) {
34027       {
34028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34029       };
34030     }
34031   }
34032   jresult = (void *)result;
34033   return jresult;
34034 }
34035
34036
34037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
34038   void * jresult ;
34039   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34040   Dali::Stage::WheelEventSignalType *result = 0 ;
34041
34042   arg1 = (Dali::Stage *)jarg1;
34043   {
34044     try {
34045       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
34046     } catch (std::out_of_range& e) {
34047       {
34048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34049       };
34050     } catch (std::exception& e) {
34051       {
34052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34053       };
34054     } catch (...) {
34055       {
34056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34057       };
34058     }
34059   }
34060   jresult = (void *)result;
34061   return jresult;
34062 }
34063
34064
34065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
34066   void * jresult ;
34067   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34068   Dali::Stage::ContextStatusSignal *result = 0 ;
34069
34070   arg1 = (Dali::Stage *)jarg1;
34071   {
34072     try {
34073       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
34074     } catch (std::out_of_range& e) {
34075       {
34076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34077       };
34078     } catch (std::exception& e) {
34079       {
34080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34081       };
34082     } catch (...) {
34083       {
34084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34085       };
34086     }
34087   }
34088   jresult = (void *)result;
34089   return jresult;
34090 }
34091
34092
34093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
34094   void * jresult ;
34095   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34096   Dali::Stage::ContextStatusSignal *result = 0 ;
34097
34098   arg1 = (Dali::Stage *)jarg1;
34099   {
34100     try {
34101       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
34102     } catch (std::out_of_range& e) {
34103       {
34104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34105       };
34106     } catch (std::exception& e) {
34107       {
34108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34109       };
34110     } catch (...) {
34111       {
34112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34113       };
34114     }
34115   }
34116   jresult = (void *)result;
34117   return jresult;
34118 }
34119
34120
34121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
34122   void * jresult ;
34123   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34124   Dali::Stage::SceneCreatedSignalType *result = 0 ;
34125
34126   arg1 = (Dali::Stage *)jarg1;
34127   {
34128     try {
34129       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
34130     } catch (std::out_of_range& e) {
34131       {
34132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34133       };
34134     } catch (std::exception& e) {
34135       {
34136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34137       };
34138     } catch (...) {
34139       {
34140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34141       };
34142     }
34143   }
34144   jresult = (void *)result;
34145   return jresult;
34146 }
34147
34148
34149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
34150   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34151
34152   arg1 = (Dali::RelayoutContainer *)jarg1;
34153   {
34154     try {
34155       delete arg1;
34156     } catch (std::out_of_range& e) {
34157       {
34158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34159       };
34160     } catch (std::exception& e) {
34161       {
34162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34163       };
34164     } catch (...) {
34165       {
34166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34167       };
34168     }
34169   }
34170 }
34171
34172
34173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34174   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34175   Dali::Actor *arg2 = 0 ;
34176   Dali::Vector2 *arg3 = 0 ;
34177
34178   arg1 = (Dali::RelayoutContainer *)jarg1;
34179   arg2 = (Dali::Actor *)jarg2;
34180   if (!arg2) {
34181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34182     return ;
34183   }
34184   arg3 = (Dali::Vector2 *)jarg3;
34185   if (!arg3) {
34186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34187     return ;
34188   }
34189   {
34190     try {
34191       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34192     } catch (std::out_of_range& e) {
34193       {
34194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34195       };
34196     } catch (std::exception& e) {
34197       {
34198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34199       };
34200     } catch (...) {
34201       {
34202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34203       };
34204     }
34205   }
34206 }
34207
34208
34209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34210   void * jresult ;
34211   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34212   Dali::CustomActor result;
34213
34214   arg1 = (Dali::CustomActorImpl *)jarg1;
34215   {
34216     try {
34217       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34218     } catch (std::out_of_range& e) {
34219       {
34220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34221       };
34222     } catch (std::exception& e) {
34223       {
34224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34225       };
34226     } catch (...) {
34227       {
34228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34229       };
34230     }
34231   }
34232   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34233   return jresult;
34234 }
34235
34236
34237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34238   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34239   int arg2 ;
34240
34241   arg1 = (Dali::CustomActorImpl *)jarg1;
34242   arg2 = (int)jarg2;
34243   {
34244     try {
34245       (arg1)->OnStageConnection(arg2);
34246     } catch (std::out_of_range& e) {
34247       {
34248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34249       };
34250     } catch (std::exception& e) {
34251       {
34252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34253       };
34254     } catch (...) {
34255       {
34256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34257       };
34258     }
34259   }
34260 }
34261
34262
34263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34264   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34265
34266   arg1 = (Dali::CustomActorImpl *)jarg1;
34267   {
34268     try {
34269       (arg1)->OnStageDisconnection();
34270     } catch (std::out_of_range& e) {
34271       {
34272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34273       };
34274     } catch (std::exception& e) {
34275       {
34276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34277       };
34278     } catch (...) {
34279       {
34280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34281       };
34282     }
34283   }
34284 }
34285
34286
34287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34288   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34289   Dali::Actor *arg2 = 0 ;
34290
34291   arg1 = (Dali::CustomActorImpl *)jarg1;
34292   arg2 = (Dali::Actor *)jarg2;
34293   if (!arg2) {
34294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34295     return ;
34296   }
34297   {
34298     try {
34299       (arg1)->OnChildAdd(*arg2);
34300     } catch (std::out_of_range& e) {
34301       {
34302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34303       };
34304     } catch (std::exception& e) {
34305       {
34306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34307       };
34308     } catch (...) {
34309       {
34310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34311       };
34312     }
34313   }
34314 }
34315
34316
34317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34318   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34319   Dali::Actor *arg2 = 0 ;
34320
34321   arg1 = (Dali::CustomActorImpl *)jarg1;
34322   arg2 = (Dali::Actor *)jarg2;
34323   if (!arg2) {
34324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34325     return ;
34326   }
34327   {
34328     try {
34329       (arg1)->OnChildRemove(*arg2);
34330     } catch (std::out_of_range& e) {
34331       {
34332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34333       };
34334     } catch (std::exception& e) {
34335       {
34336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34337       };
34338     } catch (...) {
34339       {
34340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34341       };
34342     }
34343   }
34344 }
34345
34346
34347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34348   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34349   Dali::Property::Index arg2 ;
34350   Dali::Property::Value arg3 ;
34351   Dali::Property::Value *argp3 ;
34352
34353   arg1 = (Dali::CustomActorImpl *)jarg1;
34354   arg2 = (Dali::Property::Index)jarg2;
34355   argp3 = (Dali::Property::Value *)jarg3;
34356   if (!argp3) {
34357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34358     return ;
34359   }
34360   arg3 = *argp3;
34361   {
34362     try {
34363       (arg1)->OnPropertySet(arg2,arg3);
34364     } catch (std::out_of_range& e) {
34365       {
34366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34367       };
34368     } catch (std::exception& e) {
34369       {
34370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34371       };
34372     } catch (...) {
34373       {
34374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34375       };
34376     }
34377   }
34378 }
34379
34380
34381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34382   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34383   Dali::Vector3 *arg2 = 0 ;
34384
34385   arg1 = (Dali::CustomActorImpl *)jarg1;
34386   arg2 = (Dali::Vector3 *)jarg2;
34387   if (!arg2) {
34388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34389     return ;
34390   }
34391   {
34392     try {
34393       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34394     } catch (std::out_of_range& e) {
34395       {
34396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34397       };
34398     } catch (std::exception& e) {
34399       {
34400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34401       };
34402     } catch (...) {
34403       {
34404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34405       };
34406     }
34407   }
34408 }
34409
34410
34411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34412   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34413   Dali::Animation *arg2 = 0 ;
34414   Dali::Vector3 *arg3 = 0 ;
34415
34416   arg1 = (Dali::CustomActorImpl *)jarg1;
34417   arg2 = (Dali::Animation *)jarg2;
34418   if (!arg2) {
34419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34420     return ;
34421   }
34422   arg3 = (Dali::Vector3 *)jarg3;
34423   if (!arg3) {
34424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34425     return ;
34426   }
34427   {
34428     try {
34429       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34430     } catch (std::out_of_range& e) {
34431       {
34432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34433       };
34434     } catch (std::exception& e) {
34435       {
34436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34437       };
34438     } catch (...) {
34439       {
34440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34441       };
34442     }
34443   }
34444 }
34445
34446
34447 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34448   unsigned int jresult ;
34449   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34450   Dali::TouchEvent *arg2 = 0 ;
34451   bool result;
34452
34453   arg1 = (Dali::CustomActorImpl *)jarg1;
34454   arg2 = (Dali::TouchEvent *)jarg2;
34455   if (!arg2) {
34456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34457     return 0;
34458   }
34459   {
34460     try {
34461       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34462     } catch (std::out_of_range& e) {
34463       {
34464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34465       };
34466     } catch (std::exception& e) {
34467       {
34468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34469       };
34470     } catch (...) {
34471       {
34472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34473       };
34474     }
34475   }
34476   jresult = result;
34477   return jresult;
34478 }
34479
34480
34481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34482   unsigned int jresult ;
34483   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34484   Dali::HoverEvent *arg2 = 0 ;
34485   bool result;
34486
34487   arg1 = (Dali::CustomActorImpl *)jarg1;
34488   arg2 = (Dali::HoverEvent *)jarg2;
34489   if (!arg2) {
34490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34491     return 0;
34492   }
34493   {
34494     try {
34495       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34496     } catch (std::out_of_range& e) {
34497       {
34498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34499       };
34500     } catch (std::exception& e) {
34501       {
34502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34503       };
34504     } catch (...) {
34505       {
34506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34507       };
34508     }
34509   }
34510   jresult = result;
34511   return jresult;
34512 }
34513
34514
34515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34516   unsigned int jresult ;
34517   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34518   Dali::KeyEvent *arg2 = 0 ;
34519   bool result;
34520
34521   arg1 = (Dali::CustomActorImpl *)jarg1;
34522   arg2 = (Dali::KeyEvent *)jarg2;
34523   if (!arg2) {
34524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34525     return 0;
34526   }
34527   {
34528     try {
34529       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34530     } catch (std::out_of_range& e) {
34531       {
34532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34533       };
34534     } catch (std::exception& e) {
34535       {
34536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34537       };
34538     } catch (...) {
34539       {
34540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34541       };
34542     }
34543   }
34544   jresult = result;
34545   return jresult;
34546 }
34547
34548
34549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34550   unsigned int jresult ;
34551   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34552   Dali::WheelEvent *arg2 = 0 ;
34553   bool result;
34554
34555   arg1 = (Dali::CustomActorImpl *)jarg1;
34556   arg2 = (Dali::WheelEvent *)jarg2;
34557   if (!arg2) {
34558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34559     return 0;
34560   }
34561   {
34562     try {
34563       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*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 void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34584   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34585   Dali::Vector2 *arg2 = 0 ;
34586   Dali::RelayoutContainer *arg3 = 0 ;
34587
34588   arg1 = (Dali::CustomActorImpl *)jarg1;
34589   arg2 = (Dali::Vector2 *)jarg2;
34590   if (!arg2) {
34591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34592     return ;
34593   }
34594   arg3 = (Dali::RelayoutContainer *)jarg3;
34595   if (!arg3) {
34596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34597     return ;
34598   }
34599   {
34600     try {
34601       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34602     } catch (std::out_of_range& e) {
34603       {
34604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34605       };
34606     } catch (std::exception& e) {
34607       {
34608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34609       };
34610     } catch (...) {
34611       {
34612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34613       };
34614     }
34615   }
34616 }
34617
34618
34619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34620   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34621   Dali::ResizePolicy::Type arg2 ;
34622   Dali::Dimension::Type arg3 ;
34623
34624   arg1 = (Dali::CustomActorImpl *)jarg1;
34625   arg2 = (Dali::ResizePolicy::Type)jarg2;
34626   arg3 = (Dali::Dimension::Type)jarg3;
34627   {
34628     try {
34629       (arg1)->OnSetResizePolicy(arg2,arg3);
34630     } catch (std::out_of_range& e) {
34631       {
34632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34633       };
34634     } catch (std::exception& e) {
34635       {
34636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34637       };
34638     } catch (...) {
34639       {
34640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34641       };
34642     }
34643   }
34644 }
34645
34646
34647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34648   void * jresult ;
34649   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34650   Dali::Vector3 result;
34651
34652   arg1 = (Dali::CustomActorImpl *)jarg1;
34653   {
34654     try {
34655       result = (arg1)->GetNaturalSize();
34656     } catch (std::out_of_range& e) {
34657       {
34658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34659       };
34660     } catch (std::exception& e) {
34661       {
34662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34663       };
34664     } catch (...) {
34665       {
34666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34667       };
34668     }
34669   }
34670   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34671   return jresult;
34672 }
34673
34674
34675 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34676   float jresult ;
34677   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34678   Dali::Actor *arg2 = 0 ;
34679   Dali::Dimension::Type arg3 ;
34680   float result;
34681
34682   arg1 = (Dali::CustomActorImpl *)jarg1;
34683   arg2 = (Dali::Actor *)jarg2;
34684   if (!arg2) {
34685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34686     return 0;
34687   }
34688   arg3 = (Dali::Dimension::Type)jarg3;
34689   {
34690     try {
34691       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34692     } catch (std::out_of_range& e) {
34693       {
34694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34695       };
34696     } catch (std::exception& e) {
34697       {
34698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34699       };
34700     } catch (...) {
34701       {
34702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34703       };
34704     }
34705   }
34706   jresult = result;
34707   return jresult;
34708 }
34709
34710
34711 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34712   float jresult ;
34713   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34714   float arg2 ;
34715   float result;
34716
34717   arg1 = (Dali::CustomActorImpl *)jarg1;
34718   arg2 = (float)jarg2;
34719   {
34720     try {
34721       result = (float)(arg1)->GetHeightForWidth(arg2);
34722     } catch (std::out_of_range& e) {
34723       {
34724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34725       };
34726     } catch (std::exception& e) {
34727       {
34728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34729       };
34730     } catch (...) {
34731       {
34732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34733       };
34734     }
34735   }
34736   jresult = result;
34737   return jresult;
34738 }
34739
34740
34741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34742   float jresult ;
34743   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34744   float arg2 ;
34745   float result;
34746
34747   arg1 = (Dali::CustomActorImpl *)jarg1;
34748   arg2 = (float)jarg2;
34749   {
34750     try {
34751       result = (float)(arg1)->GetWidthForHeight(arg2);
34752     } catch (std::out_of_range& e) {
34753       {
34754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34755       };
34756     } catch (std::exception& e) {
34757       {
34758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34759       };
34760     } catch (...) {
34761       {
34762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34763       };
34764     }
34765   }
34766   jresult = result;
34767   return jresult;
34768 }
34769
34770
34771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34772   unsigned int jresult ;
34773   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34774   Dali::Dimension::Type arg2 ;
34775   bool result;
34776
34777   arg1 = (Dali::CustomActorImpl *)jarg1;
34778   arg2 = (Dali::Dimension::Type)jarg2;
34779   {
34780     try {
34781       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34782     } catch (std::out_of_range& e) {
34783       {
34784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34785       };
34786     } catch (std::exception& e) {
34787       {
34788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34789       };
34790     } catch (...) {
34791       {
34792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34793       };
34794     }
34795   }
34796   jresult = result;
34797   return jresult;
34798 }
34799
34800
34801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34802   unsigned int jresult ;
34803   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34804   bool result;
34805
34806   arg1 = (Dali::CustomActorImpl *)jarg1;
34807   {
34808     try {
34809       result = (bool)(arg1)->RelayoutDependentOnChildren();
34810     } catch (std::out_of_range& e) {
34811       {
34812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34813       };
34814     } catch (std::exception& e) {
34815       {
34816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34817       };
34818     } catch (...) {
34819       {
34820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34821       };
34822     }
34823   }
34824   jresult = result;
34825   return jresult;
34826 }
34827
34828
34829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34830   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34831   Dali::Dimension::Type arg2 ;
34832
34833   arg1 = (Dali::CustomActorImpl *)jarg1;
34834   arg2 = (Dali::Dimension::Type)jarg2;
34835   {
34836     try {
34837       (arg1)->OnCalculateRelayoutSize(arg2);
34838     } catch (std::out_of_range& e) {
34839       {
34840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34841       };
34842     } catch (std::exception& e) {
34843       {
34844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34845       };
34846     } catch (...) {
34847       {
34848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34849       };
34850     }
34851   }
34852 }
34853
34854
34855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34856   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34857   float arg2 ;
34858   Dali::Dimension::Type arg3 ;
34859
34860   arg1 = (Dali::CustomActorImpl *)jarg1;
34861   arg2 = (float)jarg2;
34862   arg3 = (Dali::Dimension::Type)jarg3;
34863   {
34864     try {
34865       (arg1)->OnLayoutNegotiated(arg2,arg3);
34866     } catch (std::out_of_range& e) {
34867       {
34868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34869       };
34870     } catch (std::exception& e) {
34871       {
34872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34873       };
34874     } catch (...) {
34875       {
34876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34877       };
34878     }
34879   }
34880 }
34881
34882
34883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34884   unsigned int jresult ;
34885   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34886   bool result;
34887
34888   arg1 = (Dali::CustomActorImpl *)jarg1;
34889   {
34890     try {
34891       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34892     } catch (std::out_of_range& e) {
34893       {
34894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34895       };
34896     } catch (std::exception& e) {
34897       {
34898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34899       };
34900     } catch (...) {
34901       {
34902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34903       };
34904     }
34905   }
34906   jresult = result;
34907   return jresult;
34908 }
34909
34910
34911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34912   unsigned int jresult ;
34913   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34914   bool result;
34915
34916   arg1 = (Dali::CustomActorImpl *)jarg1;
34917   {
34918     try {
34919       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34920     } catch (std::out_of_range& e) {
34921       {
34922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34923       };
34924     } catch (std::exception& e) {
34925       {
34926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34927       };
34928     } catch (...) {
34929       {
34930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34931       };
34932     }
34933   }
34934   jresult = result;
34935   return jresult;
34936 }
34937
34938
34939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34940   unsigned int jresult ;
34941   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34942   bool result;
34943
34944   arg1 = (Dali::CustomActorImpl *)jarg1;
34945   {
34946     try {
34947       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34948     } catch (std::out_of_range& e) {
34949       {
34950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34951       };
34952     } catch (std::exception& e) {
34953       {
34954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34955       };
34956     } catch (...) {
34957       {
34958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34959       };
34960     }
34961   }
34962   jresult = result;
34963   return jresult;
34964 }
34965
34966
34967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34968   unsigned int jresult ;
34969   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34970   bool result;
34971
34972   arg1 = (Dali::CustomActorImpl *)jarg1;
34973   {
34974     try {
34975       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34976     } catch (std::out_of_range& e) {
34977       {
34978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34979       };
34980     } catch (std::exception& e) {
34981       {
34982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34983       };
34984     } catch (...) {
34985       {
34986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34987       };
34988     }
34989   }
34990   jresult = result;
34991   return jresult;
34992 }
34993
34994
34995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
34996   void * jresult ;
34997   Dali::CustomActor *result = 0 ;
34998
34999   {
35000     try {
35001       result = (Dali::CustomActor *)new Dali::CustomActor();
35002     } catch (std::out_of_range& e) {
35003       {
35004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35005       };
35006     } catch (std::exception& e) {
35007       {
35008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35009       };
35010     } catch (...) {
35011       {
35012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35013       };
35014     }
35015   }
35016   jresult = (void *)result;
35017   return jresult;
35018 }
35019
35020
35021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
35022   void * jresult ;
35023   Dali::BaseHandle arg1 ;
35024   Dali::BaseHandle *argp1 ;
35025   Dali::CustomActor result;
35026
35027   argp1 = (Dali::BaseHandle *)jarg1;
35028   if (!argp1) {
35029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35030     return 0;
35031   }
35032   arg1 = *argp1;
35033   {
35034     try {
35035       result = Dali::CustomActor::DownCast(arg1);
35036     } catch (std::out_of_range& e) {
35037       {
35038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35039       };
35040     } catch (std::exception& e) {
35041       {
35042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35043       };
35044     } catch (...) {
35045       {
35046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35047       };
35048     }
35049   }
35050   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
35051   return jresult;
35052 }
35053
35054
35055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
35056   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35057
35058   arg1 = (Dali::CustomActor *)jarg1;
35059   {
35060     try {
35061       delete arg1;
35062     } catch (std::out_of_range& e) {
35063       {
35064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35065       };
35066     } catch (std::exception& e) {
35067       {
35068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35069       };
35070     } catch (...) {
35071       {
35072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35073       };
35074     }
35075   }
35076 }
35077
35078
35079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
35080   void * jresult ;
35081   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35082   Dali::CustomActorImpl *result = 0 ;
35083
35084   arg1 = (Dali::CustomActor *)jarg1;
35085   {
35086     try {
35087       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
35088     } catch (std::out_of_range& e) {
35089       {
35090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35091       };
35092     } catch (std::exception& e) {
35093       {
35094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35095       };
35096     } catch (...) {
35097       {
35098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35099       };
35100     }
35101   }
35102   jresult = (void *)result;
35103   return jresult;
35104 }
35105
35106
35107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
35108   void * jresult ;
35109   Dali::CustomActorImpl *arg1 = 0 ;
35110   Dali::CustomActor *result = 0 ;
35111
35112   arg1 = (Dali::CustomActorImpl *)jarg1;
35113   if (!arg1) {
35114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
35115     return 0;
35116   }
35117   {
35118     try {
35119       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
35120     } catch (std::out_of_range& e) {
35121       {
35122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35123       };
35124     } catch (std::exception& e) {
35125       {
35126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35127       };
35128     } catch (...) {
35129       {
35130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35131       };
35132     }
35133   }
35134   jresult = (void *)result;
35135   return jresult;
35136 }
35137
35138
35139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
35140   void * jresult ;
35141   Dali::CustomActor *arg1 = 0 ;
35142   Dali::CustomActor *result = 0 ;
35143
35144   arg1 = (Dali::CustomActor *)jarg1;
35145   if (!arg1) {
35146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35147     return 0;
35148   }
35149   {
35150     try {
35151       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
35152     } catch (std::out_of_range& e) {
35153       {
35154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35155       };
35156     } catch (std::exception& e) {
35157       {
35158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35159       };
35160     } catch (...) {
35161       {
35162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35163       };
35164     }
35165   }
35166   jresult = (void *)result;
35167   return jresult;
35168 }
35169
35170
35171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35172   void * jresult ;
35173   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35174   Dali::CustomActor *arg2 = 0 ;
35175   Dali::CustomActor *result = 0 ;
35176
35177   arg1 = (Dali::CustomActor *)jarg1;
35178   arg2 = (Dali::CustomActor *)jarg2;
35179   if (!arg2) {
35180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35181     return 0;
35182   }
35183   {
35184     try {
35185       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35186     } catch (std::out_of_range& e) {
35187       {
35188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35189       };
35190     } catch (std::exception& e) {
35191       {
35192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35193       };
35194     } catch (...) {
35195       {
35196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35197       };
35198     }
35199   }
35200   jresult = (void *)result;
35201   return jresult;
35202 }
35203
35204
35205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35206   int jresult ;
35207   int result;
35208
35209   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35210   jresult = (int)result;
35211   return jresult;
35212 }
35213
35214
35215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35216   int jresult ;
35217   int result;
35218
35219   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35220   jresult = (int)result;
35221   return jresult;
35222 }
35223
35224
35225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35226   int jresult ;
35227   int result;
35228
35229   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35230   jresult = (int)result;
35231   return jresult;
35232 }
35233
35234
35235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35236   int jresult ;
35237   int result;
35238
35239   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35240   jresult = (int)result;
35241   return jresult;
35242 }
35243
35244
35245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35246   int jresult ;
35247   int result;
35248
35249   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35250   jresult = (int)result;
35251   return jresult;
35252 }
35253
35254
35255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35256   int jresult ;
35257   int result;
35258
35259   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35260   jresult = (int)result;
35261   return jresult;
35262 }
35263
35264
35265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35266   int jresult ;
35267   int result;
35268
35269   result = (int)Dali::PanGestureDetector::Property::PANNING;
35270   jresult = (int)result;
35271   return jresult;
35272 }
35273
35274
35275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35276   void * jresult ;
35277   Dali::PanGestureDetector::Property *result = 0 ;
35278
35279   {
35280     try {
35281       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35282     } catch (std::out_of_range& e) {
35283       {
35284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35285       };
35286     } catch (std::exception& e) {
35287       {
35288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35289       };
35290     } catch (...) {
35291       {
35292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35293       };
35294     }
35295   }
35296   jresult = (void *)result;
35297   return jresult;
35298 }
35299
35300
35301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35302   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35303
35304   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35305   {
35306     try {
35307       delete arg1;
35308     } catch (std::out_of_range& e) {
35309       {
35310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35311       };
35312     } catch (std::exception& e) {
35313       {
35314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35315       };
35316     } catch (...) {
35317       {
35318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35319       };
35320     }
35321   }
35322 }
35323
35324
35325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35326   void * jresult ;
35327   Dali::Radian *result = 0 ;
35328
35329   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35330   jresult = (void *)result;
35331   return jresult;
35332 }
35333
35334
35335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35336   void * jresult ;
35337   Dali::Radian *result = 0 ;
35338
35339   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35340   jresult = (void *)result;
35341   return jresult;
35342 }
35343
35344
35345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35346   void * jresult ;
35347   Dali::Radian *result = 0 ;
35348
35349   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35350   jresult = (void *)result;
35351   return jresult;
35352 }
35353
35354
35355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35356   void * jresult ;
35357   Dali::Radian *result = 0 ;
35358
35359   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35360   jresult = (void *)result;
35361   return jresult;
35362 }
35363
35364
35365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35366   void * jresult ;
35367   Dali::Radian *result = 0 ;
35368
35369   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35370   jresult = (void *)result;
35371   return jresult;
35372 }
35373
35374
35375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35376   void * jresult ;
35377   Dali::Radian *result = 0 ;
35378
35379   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35380   jresult = (void *)result;
35381   return jresult;
35382 }
35383
35384
35385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35386   void * jresult ;
35387   Dali::Radian *result = 0 ;
35388
35389   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35390   jresult = (void *)result;
35391   return jresult;
35392 }
35393
35394
35395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35396   void * jresult ;
35397   Dali::PanGestureDetector *result = 0 ;
35398
35399   {
35400     try {
35401       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35402     } catch (std::out_of_range& e) {
35403       {
35404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35405       };
35406     } catch (std::exception& e) {
35407       {
35408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35409       };
35410     } catch (...) {
35411       {
35412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35413       };
35414     }
35415   }
35416   jresult = (void *)result;
35417   return jresult;
35418 }
35419
35420
35421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35422   void * jresult ;
35423   Dali::PanGestureDetector result;
35424
35425   {
35426     try {
35427       result = Dali::PanGestureDetector::New();
35428     } catch (std::out_of_range& e) {
35429       {
35430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35431       };
35432     } catch (std::exception& e) {
35433       {
35434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35435       };
35436     } catch (...) {
35437       {
35438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35439       };
35440     }
35441   }
35442   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35443   return jresult;
35444 }
35445
35446
35447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35448   void * jresult ;
35449   Dali::BaseHandle arg1 ;
35450   Dali::BaseHandle *argp1 ;
35451   Dali::PanGestureDetector result;
35452
35453   argp1 = (Dali::BaseHandle *)jarg1;
35454   if (!argp1) {
35455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35456     return 0;
35457   }
35458   arg1 = *argp1;
35459   {
35460     try {
35461       result = Dali::PanGestureDetector::DownCast(arg1);
35462     } catch (std::out_of_range& e) {
35463       {
35464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35465       };
35466     } catch (std::exception& e) {
35467       {
35468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35469       };
35470     } catch (...) {
35471       {
35472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35473       };
35474     }
35475   }
35476   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35477   return jresult;
35478 }
35479
35480
35481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35482   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35483
35484   arg1 = (Dali::PanGestureDetector *)jarg1;
35485   {
35486     try {
35487       delete arg1;
35488     } catch (std::out_of_range& e) {
35489       {
35490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35491       };
35492     } catch (std::exception& e) {
35493       {
35494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35495       };
35496     } catch (...) {
35497       {
35498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35499       };
35500     }
35501   }
35502 }
35503
35504
35505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35506   void * jresult ;
35507   Dali::PanGestureDetector *arg1 = 0 ;
35508   Dali::PanGestureDetector *result = 0 ;
35509
35510   arg1 = (Dali::PanGestureDetector *)jarg1;
35511   if (!arg1) {
35512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35513     return 0;
35514   }
35515   {
35516     try {
35517       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35518     } catch (std::out_of_range& e) {
35519       {
35520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35521       };
35522     } catch (std::exception& e) {
35523       {
35524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35525       };
35526     } catch (...) {
35527       {
35528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35529       };
35530     }
35531   }
35532   jresult = (void *)result;
35533   return jresult;
35534 }
35535
35536
35537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35538   void * jresult ;
35539   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35540   Dali::PanGestureDetector *arg2 = 0 ;
35541   Dali::PanGestureDetector *result = 0 ;
35542
35543   arg1 = (Dali::PanGestureDetector *)jarg1;
35544   arg2 = (Dali::PanGestureDetector *)jarg2;
35545   if (!arg2) {
35546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35547     return 0;
35548   }
35549   {
35550     try {
35551       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35552     } catch (std::out_of_range& e) {
35553       {
35554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35555       };
35556     } catch (std::exception& e) {
35557       {
35558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35559       };
35560     } catch (...) {
35561       {
35562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35563       };
35564     }
35565   }
35566   jresult = (void *)result;
35567   return jresult;
35568 }
35569
35570
35571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35572   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35573   unsigned int arg2 ;
35574
35575   arg1 = (Dali::PanGestureDetector *)jarg1;
35576   arg2 = (unsigned int)jarg2;
35577   {
35578     try {
35579       (arg1)->SetMinimumTouchesRequired(arg2);
35580     } catch (std::out_of_range& e) {
35581       {
35582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35583       };
35584     } catch (std::exception& e) {
35585       {
35586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35587       };
35588     } catch (...) {
35589       {
35590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35591       };
35592     }
35593   }
35594 }
35595
35596
35597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35598   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35599   unsigned int arg2 ;
35600
35601   arg1 = (Dali::PanGestureDetector *)jarg1;
35602   arg2 = (unsigned int)jarg2;
35603   {
35604     try {
35605       (arg1)->SetMaximumTouchesRequired(arg2);
35606     } catch (std::out_of_range& e) {
35607       {
35608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35609       };
35610     } catch (std::exception& e) {
35611       {
35612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35613       };
35614     } catch (...) {
35615       {
35616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35617       };
35618     }
35619   }
35620 }
35621
35622
35623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35624   unsigned int jresult ;
35625   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35626   unsigned int result;
35627
35628   arg1 = (Dali::PanGestureDetector *)jarg1;
35629   {
35630     try {
35631       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35632     } catch (std::out_of_range& e) {
35633       {
35634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35635       };
35636     } catch (std::exception& e) {
35637       {
35638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35639       };
35640     } catch (...) {
35641       {
35642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35643       };
35644     }
35645   }
35646   jresult = result;
35647   return jresult;
35648 }
35649
35650
35651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35652   unsigned int jresult ;
35653   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35654   unsigned int result;
35655
35656   arg1 = (Dali::PanGestureDetector *)jarg1;
35657   {
35658     try {
35659       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35660     } catch (std::out_of_range& e) {
35661       {
35662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35663       };
35664     } catch (std::exception& e) {
35665       {
35666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35667       };
35668     } catch (...) {
35669       {
35670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35671       };
35672     }
35673   }
35674   jresult = result;
35675   return jresult;
35676 }
35677
35678
35679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35680   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35681   Dali::Radian arg2 ;
35682   Dali::Radian arg3 ;
35683   Dali::Radian *argp2 ;
35684   Dali::Radian *argp3 ;
35685
35686   arg1 = (Dali::PanGestureDetector *)jarg1;
35687   argp2 = (Dali::Radian *)jarg2;
35688   if (!argp2) {
35689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35690     return ;
35691   }
35692   arg2 = *argp2;
35693   argp3 = (Dali::Radian *)jarg3;
35694   if (!argp3) {
35695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35696     return ;
35697   }
35698   arg3 = *argp3;
35699   {
35700     try {
35701       (arg1)->AddAngle(arg2,arg3);
35702     } catch (std::out_of_range& e) {
35703       {
35704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35705       };
35706     } catch (std::exception& e) {
35707       {
35708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35709       };
35710     } catch (...) {
35711       {
35712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35713       };
35714     }
35715   }
35716 }
35717
35718
35719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35720   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35721   Dali::Radian arg2 ;
35722   Dali::Radian *argp2 ;
35723
35724   arg1 = (Dali::PanGestureDetector *)jarg1;
35725   argp2 = (Dali::Radian *)jarg2;
35726   if (!argp2) {
35727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35728     return ;
35729   }
35730   arg2 = *argp2;
35731   {
35732     try {
35733       (arg1)->AddAngle(arg2);
35734     } catch (std::out_of_range& e) {
35735       {
35736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35737       };
35738     } catch (std::exception& e) {
35739       {
35740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35741       };
35742     } catch (...) {
35743       {
35744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35745       };
35746     }
35747   }
35748 }
35749
35750
35751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35752   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35753   Dali::Radian arg2 ;
35754   Dali::Radian arg3 ;
35755   Dali::Radian *argp2 ;
35756   Dali::Radian *argp3 ;
35757
35758   arg1 = (Dali::PanGestureDetector *)jarg1;
35759   argp2 = (Dali::Radian *)jarg2;
35760   if (!argp2) {
35761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35762     return ;
35763   }
35764   arg2 = *argp2;
35765   argp3 = (Dali::Radian *)jarg3;
35766   if (!argp3) {
35767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35768     return ;
35769   }
35770   arg3 = *argp3;
35771   {
35772     try {
35773       (arg1)->AddDirection(arg2,arg3);
35774     } catch (std::out_of_range& e) {
35775       {
35776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35777       };
35778     } catch (std::exception& e) {
35779       {
35780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35781       };
35782     } catch (...) {
35783       {
35784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35785       };
35786     }
35787   }
35788 }
35789
35790
35791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35792   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35793   Dali::Radian arg2 ;
35794   Dali::Radian *argp2 ;
35795
35796   arg1 = (Dali::PanGestureDetector *)jarg1;
35797   argp2 = (Dali::Radian *)jarg2;
35798   if (!argp2) {
35799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35800     return ;
35801   }
35802   arg2 = *argp2;
35803   {
35804     try {
35805       (arg1)->AddDirection(arg2);
35806     } catch (std::out_of_range& e) {
35807       {
35808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35809       };
35810     } catch (std::exception& e) {
35811       {
35812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35813       };
35814     } catch (...) {
35815       {
35816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35817       };
35818     }
35819   }
35820 }
35821
35822
35823 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35824   unsigned long jresult ;
35825   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35826   size_t result;
35827
35828   arg1 = (Dali::PanGestureDetector *)jarg1;
35829   {
35830     try {
35831       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35832     } catch (std::out_of_range& e) {
35833       {
35834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35835       };
35836     } catch (std::exception& e) {
35837       {
35838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35839       };
35840     } catch (...) {
35841       {
35842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35843       };
35844     }
35845   }
35846   jresult = (unsigned long)result;
35847   return jresult;
35848 }
35849
35850
35851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35852   void * jresult ;
35853   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35854   size_t arg2 ;
35855   Dali::PanGestureDetector::AngleThresholdPair result;
35856
35857   arg1 = (Dali::PanGestureDetector *)jarg1;
35858   arg2 = (size_t)jarg2;
35859   {
35860     try {
35861       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35862     } catch (std::out_of_range& e) {
35863       {
35864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35865       };
35866     } catch (std::exception& e) {
35867       {
35868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35869       };
35870     } catch (...) {
35871       {
35872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35873       };
35874     }
35875   }
35876   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35877   return jresult;
35878 }
35879
35880
35881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35882   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35883
35884   arg1 = (Dali::PanGestureDetector *)jarg1;
35885   {
35886     try {
35887       (arg1)->ClearAngles();
35888     } catch (std::out_of_range& e) {
35889       {
35890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35891       };
35892     } catch (std::exception& e) {
35893       {
35894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35895       };
35896     } catch (...) {
35897       {
35898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35899       };
35900     }
35901   }
35902 }
35903
35904
35905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35906   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35907   Dali::Radian arg2 ;
35908   Dali::Radian *argp2 ;
35909
35910   arg1 = (Dali::PanGestureDetector *)jarg1;
35911   argp2 = (Dali::Radian *)jarg2;
35912   if (!argp2) {
35913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35914     return ;
35915   }
35916   arg2 = *argp2;
35917   {
35918     try {
35919       (arg1)->RemoveAngle(arg2);
35920     } catch (std::out_of_range& e) {
35921       {
35922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35923       };
35924     } catch (std::exception& e) {
35925       {
35926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35927       };
35928     } catch (...) {
35929       {
35930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35931       };
35932     }
35933   }
35934 }
35935
35936
35937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35938   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35939   Dali::Radian arg2 ;
35940   Dali::Radian *argp2 ;
35941
35942   arg1 = (Dali::PanGestureDetector *)jarg1;
35943   argp2 = (Dali::Radian *)jarg2;
35944   if (!argp2) {
35945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35946     return ;
35947   }
35948   arg2 = *argp2;
35949   {
35950     try {
35951       (arg1)->RemoveDirection(arg2);
35952     } catch (std::out_of_range& e) {
35953       {
35954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35955       };
35956     } catch (std::exception& e) {
35957       {
35958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35959       };
35960     } catch (...) {
35961       {
35962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35963       };
35964     }
35965   }
35966 }
35967
35968
35969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35970   void * jresult ;
35971   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35972   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35973
35974   arg1 = (Dali::PanGestureDetector *)jarg1;
35975   {
35976     try {
35977       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
35978     } catch (std::out_of_range& e) {
35979       {
35980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35981       };
35982     } catch (std::exception& e) {
35983       {
35984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35985       };
35986     } catch (...) {
35987       {
35988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35989       };
35990     }
35991   }
35992   jresult = (void *)result;
35993   return jresult;
35994 }
35995
35996
35997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
35998   Dali::PanGesture *arg1 = 0 ;
35999
36000   arg1 = (Dali::PanGesture *)jarg1;
36001   if (!arg1) {
36002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36003     return ;
36004   }
36005   {
36006     try {
36007       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
36008     } catch (std::out_of_range& e) {
36009       {
36010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36011       };
36012     } catch (std::exception& e) {
36013       {
36014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36015       };
36016     } catch (...) {
36017       {
36018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36019       };
36020     }
36021   }
36022 }
36023
36024
36025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
36026   void * jresult ;
36027   Dali::PanGesture *result = 0 ;
36028
36029   {
36030     try {
36031       result = (Dali::PanGesture *)new Dali::PanGesture();
36032     } catch (std::out_of_range& e) {
36033       {
36034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36035       };
36036     } catch (std::exception& e) {
36037       {
36038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36039       };
36040     } catch (...) {
36041       {
36042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36043       };
36044     }
36045   }
36046   jresult = (void *)result;
36047   return jresult;
36048 }
36049
36050
36051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
36052   void * jresult ;
36053   Dali::Gesture::State arg1 ;
36054   Dali::PanGesture *result = 0 ;
36055
36056   arg1 = (Dali::Gesture::State)jarg1;
36057   {
36058     try {
36059       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
36060     } catch (std::out_of_range& e) {
36061       {
36062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36063       };
36064     } catch (std::exception& e) {
36065       {
36066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36067       };
36068     } catch (...) {
36069       {
36070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36071       };
36072     }
36073   }
36074   jresult = (void *)result;
36075   return jresult;
36076 }
36077
36078
36079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
36080   void * jresult ;
36081   Dali::PanGesture *arg1 = 0 ;
36082   Dali::PanGesture *result = 0 ;
36083
36084   arg1 = (Dali::PanGesture *)jarg1;
36085   if (!arg1) {
36086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36087     return 0;
36088   }
36089   {
36090     try {
36091       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
36092     } catch (std::out_of_range& e) {
36093       {
36094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36095       };
36096     } catch (std::exception& e) {
36097       {
36098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36099       };
36100     } catch (...) {
36101       {
36102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36103       };
36104     }
36105   }
36106   jresult = (void *)result;
36107   return jresult;
36108 }
36109
36110
36111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
36112   void * jresult ;
36113   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36114   Dali::PanGesture *arg2 = 0 ;
36115   Dali::PanGesture *result = 0 ;
36116
36117   arg1 = (Dali::PanGesture *)jarg1;
36118   arg2 = (Dali::PanGesture *)jarg2;
36119   if (!arg2) {
36120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36121     return 0;
36122   }
36123   {
36124     try {
36125       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
36126     } catch (std::out_of_range& e) {
36127       {
36128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36129       };
36130     } catch (std::exception& e) {
36131       {
36132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36133       };
36134     } catch (...) {
36135       {
36136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36137       };
36138     }
36139   }
36140   jresult = (void *)result;
36141   return jresult;
36142 }
36143
36144
36145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
36146   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36147
36148   arg1 = (Dali::PanGesture *)jarg1;
36149   {
36150     try {
36151       delete arg1;
36152     } catch (std::out_of_range& e) {
36153       {
36154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36155       };
36156     } catch (std::exception& e) {
36157       {
36158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36159       };
36160     } catch (...) {
36161       {
36162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36163       };
36164     }
36165   }
36166 }
36167
36168
36169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36170   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36171   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36172
36173   arg1 = (Dali::PanGesture *)jarg1;
36174   arg2 = (Dali::Vector2 *)jarg2;
36175   if (arg1) (arg1)->velocity = *arg2;
36176 }
36177
36178
36179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36180   void * jresult ;
36181   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36182   Dali::Vector2 *result = 0 ;
36183
36184   arg1 = (Dali::PanGesture *)jarg1;
36185   result = (Dali::Vector2 *)& ((arg1)->velocity);
36186   jresult = (void *)result;
36187   return jresult;
36188 }
36189
36190
36191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36192   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36193   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36194
36195   arg1 = (Dali::PanGesture *)jarg1;
36196   arg2 = (Dali::Vector2 *)jarg2;
36197   if (arg1) (arg1)->displacement = *arg2;
36198 }
36199
36200
36201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36202   void * jresult ;
36203   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36204   Dali::Vector2 *result = 0 ;
36205
36206   arg1 = (Dali::PanGesture *)jarg1;
36207   result = (Dali::Vector2 *)& ((arg1)->displacement);
36208   jresult = (void *)result;
36209   return jresult;
36210 }
36211
36212
36213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36214   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36215   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36216
36217   arg1 = (Dali::PanGesture *)jarg1;
36218   arg2 = (Dali::Vector2 *)jarg2;
36219   if (arg1) (arg1)->position = *arg2;
36220 }
36221
36222
36223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36224   void * jresult ;
36225   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36226   Dali::Vector2 *result = 0 ;
36227
36228   arg1 = (Dali::PanGesture *)jarg1;
36229   result = (Dali::Vector2 *)& ((arg1)->position);
36230   jresult = (void *)result;
36231   return jresult;
36232 }
36233
36234
36235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36236   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36237   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36238
36239   arg1 = (Dali::PanGesture *)jarg1;
36240   arg2 = (Dali::Vector2 *)jarg2;
36241   if (arg1) (arg1)->screenVelocity = *arg2;
36242 }
36243
36244
36245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36246   void * jresult ;
36247   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36248   Dali::Vector2 *result = 0 ;
36249
36250   arg1 = (Dali::PanGesture *)jarg1;
36251   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36252   jresult = (void *)result;
36253   return jresult;
36254 }
36255
36256
36257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36258   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36259   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36260
36261   arg1 = (Dali::PanGesture *)jarg1;
36262   arg2 = (Dali::Vector2 *)jarg2;
36263   if (arg1) (arg1)->screenDisplacement = *arg2;
36264 }
36265
36266
36267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36268   void * jresult ;
36269   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36270   Dali::Vector2 *result = 0 ;
36271
36272   arg1 = (Dali::PanGesture *)jarg1;
36273   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36274   jresult = (void *)result;
36275   return jresult;
36276 }
36277
36278
36279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36280   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36281   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36282
36283   arg1 = (Dali::PanGesture *)jarg1;
36284   arg2 = (Dali::Vector2 *)jarg2;
36285   if (arg1) (arg1)->screenPosition = *arg2;
36286 }
36287
36288
36289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36290   void * jresult ;
36291   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36292   Dali::Vector2 *result = 0 ;
36293
36294   arg1 = (Dali::PanGesture *)jarg1;
36295   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36296   jresult = (void *)result;
36297   return jresult;
36298 }
36299
36300
36301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36302   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36303   unsigned int arg2 ;
36304
36305   arg1 = (Dali::PanGesture *)jarg1;
36306   arg2 = (unsigned int)jarg2;
36307   if (arg1) (arg1)->numberOfTouches = arg2;
36308 }
36309
36310
36311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36312   unsigned int jresult ;
36313   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36314   unsigned int result;
36315
36316   arg1 = (Dali::PanGesture *)jarg1;
36317   result = (unsigned int) ((arg1)->numberOfTouches);
36318   jresult = result;
36319   return jresult;
36320 }
36321
36322
36323 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36324   float jresult ;
36325   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36326   float result;
36327
36328   arg1 = (Dali::PanGesture *)jarg1;
36329   {
36330     try {
36331       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36332     } catch (std::out_of_range& e) {
36333       {
36334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36335       };
36336     } catch (std::exception& e) {
36337       {
36338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36339       };
36340     } catch (...) {
36341       {
36342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36343       };
36344     }
36345   }
36346   jresult = result;
36347   return jresult;
36348 }
36349
36350
36351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36352   float jresult ;
36353   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36354   float result;
36355
36356   arg1 = (Dali::PanGesture *)jarg1;
36357   {
36358     try {
36359       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36360     } catch (std::out_of_range& e) {
36361       {
36362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36363       };
36364     } catch (std::exception& e) {
36365       {
36366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36367       };
36368     } catch (...) {
36369       {
36370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36371       };
36372     }
36373   }
36374   jresult = result;
36375   return jresult;
36376 }
36377
36378
36379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36380   float jresult ;
36381   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36382   float result;
36383
36384   arg1 = (Dali::PanGesture *)jarg1;
36385   {
36386     try {
36387       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36388     } catch (std::out_of_range& e) {
36389       {
36390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36391       };
36392     } catch (std::exception& e) {
36393       {
36394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36395       };
36396     } catch (...) {
36397       {
36398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36399       };
36400     }
36401   }
36402   jresult = result;
36403   return jresult;
36404 }
36405
36406
36407 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36408   float jresult ;
36409   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36410   float result;
36411
36412   arg1 = (Dali::PanGesture *)jarg1;
36413   {
36414     try {
36415       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36416     } catch (std::out_of_range& e) {
36417       {
36418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36419       };
36420     } catch (std::exception& e) {
36421       {
36422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36423       };
36424     } catch (...) {
36425       {
36426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36427       };
36428     }
36429   }
36430   jresult = result;
36431   return jresult;
36432 }
36433
36434
36435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36436   void * jresult ;
36437   Dali::PinchGestureDetector *result = 0 ;
36438
36439   {
36440     try {
36441       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36442     } catch (std::out_of_range& e) {
36443       {
36444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36445       };
36446     } catch (std::exception& e) {
36447       {
36448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36449       };
36450     } catch (...) {
36451       {
36452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36453       };
36454     }
36455   }
36456   jresult = (void *)result;
36457   return jresult;
36458 }
36459
36460
36461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36462   void * jresult ;
36463   Dali::PinchGestureDetector result;
36464
36465   {
36466     try {
36467       result = Dali::PinchGestureDetector::New();
36468     } catch (std::out_of_range& e) {
36469       {
36470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36471       };
36472     } catch (std::exception& e) {
36473       {
36474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36475       };
36476     } catch (...) {
36477       {
36478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36479       };
36480     }
36481   }
36482   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36483   return jresult;
36484 }
36485
36486
36487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36488   void * jresult ;
36489   Dali::BaseHandle arg1 ;
36490   Dali::BaseHandle *argp1 ;
36491   Dali::PinchGestureDetector result;
36492
36493   argp1 = (Dali::BaseHandle *)jarg1;
36494   if (!argp1) {
36495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36496     return 0;
36497   }
36498   arg1 = *argp1;
36499   {
36500     try {
36501       result = Dali::PinchGestureDetector::DownCast(arg1);
36502     } catch (std::out_of_range& e) {
36503       {
36504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36505       };
36506     } catch (std::exception& e) {
36507       {
36508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36509       };
36510     } catch (...) {
36511       {
36512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36513       };
36514     }
36515   }
36516   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36517   return jresult;
36518 }
36519
36520
36521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36522   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36523
36524   arg1 = (Dali::PinchGestureDetector *)jarg1;
36525   {
36526     try {
36527       delete arg1;
36528     } catch (std::out_of_range& e) {
36529       {
36530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36531       };
36532     } catch (std::exception& e) {
36533       {
36534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36535       };
36536     } catch (...) {
36537       {
36538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36539       };
36540     }
36541   }
36542 }
36543
36544
36545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36546   void * jresult ;
36547   Dali::PinchGestureDetector *arg1 = 0 ;
36548   Dali::PinchGestureDetector *result = 0 ;
36549
36550   arg1 = (Dali::PinchGestureDetector *)jarg1;
36551   if (!arg1) {
36552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36553     return 0;
36554   }
36555   {
36556     try {
36557       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36558     } catch (std::out_of_range& e) {
36559       {
36560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36561       };
36562     } catch (std::exception& e) {
36563       {
36564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36565       };
36566     } catch (...) {
36567       {
36568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36569       };
36570     }
36571   }
36572   jresult = (void *)result;
36573   return jresult;
36574 }
36575
36576
36577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36578   void * jresult ;
36579   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36580   Dali::PinchGestureDetector *arg2 = 0 ;
36581   Dali::PinchGestureDetector *result = 0 ;
36582
36583   arg1 = (Dali::PinchGestureDetector *)jarg1;
36584   arg2 = (Dali::PinchGestureDetector *)jarg2;
36585   if (!arg2) {
36586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36587     return 0;
36588   }
36589   {
36590     try {
36591       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36592     } catch (std::out_of_range& e) {
36593       {
36594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36595       };
36596     } catch (std::exception& e) {
36597       {
36598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36599       };
36600     } catch (...) {
36601       {
36602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36603       };
36604     }
36605   }
36606   jresult = (void *)result;
36607   return jresult;
36608 }
36609
36610
36611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36612   void * jresult ;
36613   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36614   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36615
36616   arg1 = (Dali::PinchGestureDetector *)jarg1;
36617   {
36618     try {
36619       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36620     } catch (std::out_of_range& e) {
36621       {
36622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36623       };
36624     } catch (std::exception& e) {
36625       {
36626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36627       };
36628     } catch (...) {
36629       {
36630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36631       };
36632     }
36633   }
36634   jresult = (void *)result;
36635   return jresult;
36636 }
36637
36638
36639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36640   void * jresult ;
36641   Dali::Gesture::State arg1 ;
36642   Dali::PinchGesture *result = 0 ;
36643
36644   arg1 = (Dali::Gesture::State)jarg1;
36645   {
36646     try {
36647       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36648     } catch (std::out_of_range& e) {
36649       {
36650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36651       };
36652     } catch (std::exception& e) {
36653       {
36654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36655       };
36656     } catch (...) {
36657       {
36658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36659       };
36660     }
36661   }
36662   jresult = (void *)result;
36663   return jresult;
36664 }
36665
36666
36667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36668   void * jresult ;
36669   Dali::PinchGesture *arg1 = 0 ;
36670   Dali::PinchGesture *result = 0 ;
36671
36672   arg1 = (Dali::PinchGesture *)jarg1;
36673   if (!arg1) {
36674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36675     return 0;
36676   }
36677   {
36678     try {
36679       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36680     } catch (std::out_of_range& e) {
36681       {
36682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36683       };
36684     } catch (std::exception& e) {
36685       {
36686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36687       };
36688     } catch (...) {
36689       {
36690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36691       };
36692     }
36693   }
36694   jresult = (void *)result;
36695   return jresult;
36696 }
36697
36698
36699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36700   void * jresult ;
36701   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36702   Dali::PinchGesture *arg2 = 0 ;
36703   Dali::PinchGesture *result = 0 ;
36704
36705   arg1 = (Dali::PinchGesture *)jarg1;
36706   arg2 = (Dali::PinchGesture *)jarg2;
36707   if (!arg2) {
36708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36709     return 0;
36710   }
36711   {
36712     try {
36713       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36714     } catch (std::out_of_range& e) {
36715       {
36716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36717       };
36718     } catch (std::exception& e) {
36719       {
36720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36721       };
36722     } catch (...) {
36723       {
36724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36725       };
36726     }
36727   }
36728   jresult = (void *)result;
36729   return jresult;
36730 }
36731
36732
36733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36734   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36735
36736   arg1 = (Dali::PinchGesture *)jarg1;
36737   {
36738     try {
36739       delete arg1;
36740     } catch (std::out_of_range& e) {
36741       {
36742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36743       };
36744     } catch (std::exception& e) {
36745       {
36746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36747       };
36748     } catch (...) {
36749       {
36750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36751       };
36752     }
36753   }
36754 }
36755
36756
36757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36758   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36759   float arg2 ;
36760
36761   arg1 = (Dali::PinchGesture *)jarg1;
36762   arg2 = (float)jarg2;
36763   if (arg1) (arg1)->scale = arg2;
36764 }
36765
36766
36767 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36768   float jresult ;
36769   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36770   float result;
36771
36772   arg1 = (Dali::PinchGesture *)jarg1;
36773   result = (float) ((arg1)->scale);
36774   jresult = result;
36775   return jresult;
36776 }
36777
36778
36779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36780   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36781   float arg2 ;
36782
36783   arg1 = (Dali::PinchGesture *)jarg1;
36784   arg2 = (float)jarg2;
36785   if (arg1) (arg1)->speed = arg2;
36786 }
36787
36788
36789 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36790   float jresult ;
36791   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36792   float result;
36793
36794   arg1 = (Dali::PinchGesture *)jarg1;
36795   result = (float) ((arg1)->speed);
36796   jresult = result;
36797   return jresult;
36798 }
36799
36800
36801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36802   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36803   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36804
36805   arg1 = (Dali::PinchGesture *)jarg1;
36806   arg2 = (Dali::Vector2 *)jarg2;
36807   if (arg1) (arg1)->screenCenterPoint = *arg2;
36808 }
36809
36810
36811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36812   void * jresult ;
36813   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36814   Dali::Vector2 *result = 0 ;
36815
36816   arg1 = (Dali::PinchGesture *)jarg1;
36817   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36818   jresult = (void *)result;
36819   return jresult;
36820 }
36821
36822
36823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36824   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36825   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36826
36827   arg1 = (Dali::PinchGesture *)jarg1;
36828   arg2 = (Dali::Vector2 *)jarg2;
36829   if (arg1) (arg1)->localCenterPoint = *arg2;
36830 }
36831
36832
36833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36834   void * jresult ;
36835   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36836   Dali::Vector2 *result = 0 ;
36837
36838   arg1 = (Dali::PinchGesture *)jarg1;
36839   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36840   jresult = (void *)result;
36841   return jresult;
36842 }
36843
36844
36845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36846   void * jresult ;
36847   Dali::TapGestureDetector *result = 0 ;
36848
36849   {
36850     try {
36851       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36852     } catch (std::out_of_range& e) {
36853       {
36854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36855       };
36856     } catch (std::exception& e) {
36857       {
36858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36859       };
36860     } catch (...) {
36861       {
36862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36863       };
36864     }
36865   }
36866   jresult = (void *)result;
36867   return jresult;
36868 }
36869
36870
36871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36872   void * jresult ;
36873   Dali::TapGestureDetector result;
36874
36875   {
36876     try {
36877       result = Dali::TapGestureDetector::New();
36878     } catch (std::out_of_range& e) {
36879       {
36880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36881       };
36882     } catch (std::exception& e) {
36883       {
36884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36885       };
36886     } catch (...) {
36887       {
36888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36889       };
36890     }
36891   }
36892   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36893   return jresult;
36894 }
36895
36896
36897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36898   void * jresult ;
36899   unsigned int arg1 ;
36900   Dali::TapGestureDetector result;
36901
36902   arg1 = (unsigned int)jarg1;
36903   {
36904     try {
36905       result = Dali::TapGestureDetector::New(arg1);
36906     } catch (std::out_of_range& e) {
36907       {
36908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36909       };
36910     } catch (std::exception& e) {
36911       {
36912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36913       };
36914     } catch (...) {
36915       {
36916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36917       };
36918     }
36919   }
36920   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36921   return jresult;
36922 }
36923
36924
36925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36926   void * jresult ;
36927   Dali::BaseHandle arg1 ;
36928   Dali::BaseHandle *argp1 ;
36929   Dali::TapGestureDetector result;
36930
36931   argp1 = (Dali::BaseHandle *)jarg1;
36932   if (!argp1) {
36933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36934     return 0;
36935   }
36936   arg1 = *argp1;
36937   {
36938     try {
36939       result = Dali::TapGestureDetector::DownCast(arg1);
36940     } catch (std::out_of_range& e) {
36941       {
36942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36943       };
36944     } catch (std::exception& e) {
36945       {
36946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36947       };
36948     } catch (...) {
36949       {
36950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36951       };
36952     }
36953   }
36954   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36955   return jresult;
36956 }
36957
36958
36959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36960   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36961
36962   arg1 = (Dali::TapGestureDetector *)jarg1;
36963   {
36964     try {
36965       delete arg1;
36966     } catch (std::out_of_range& e) {
36967       {
36968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36969       };
36970     } catch (std::exception& e) {
36971       {
36972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36973       };
36974     } catch (...) {
36975       {
36976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36977       };
36978     }
36979   }
36980 }
36981
36982
36983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
36984   void * jresult ;
36985   Dali::TapGestureDetector *arg1 = 0 ;
36986   Dali::TapGestureDetector *result = 0 ;
36987
36988   arg1 = (Dali::TapGestureDetector *)jarg1;
36989   if (!arg1) {
36990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36991     return 0;
36992   }
36993   {
36994     try {
36995       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
36996     } catch (std::out_of_range& e) {
36997       {
36998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36999       };
37000     } catch (std::exception& e) {
37001       {
37002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37003       };
37004     } catch (...) {
37005       {
37006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37007       };
37008     }
37009   }
37010   jresult = (void *)result;
37011   return jresult;
37012 }
37013
37014
37015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
37016   void * jresult ;
37017   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37018   Dali::TapGestureDetector *arg2 = 0 ;
37019   Dali::TapGestureDetector *result = 0 ;
37020
37021   arg1 = (Dali::TapGestureDetector *)jarg1;
37022   arg2 = (Dali::TapGestureDetector *)jarg2;
37023   if (!arg2) {
37024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
37025     return 0;
37026   }
37027   {
37028     try {
37029       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
37030     } catch (std::out_of_range& e) {
37031       {
37032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37033       };
37034     } catch (std::exception& e) {
37035       {
37036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37037       };
37038     } catch (...) {
37039       {
37040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37041       };
37042     }
37043   }
37044   jresult = (void *)result;
37045   return jresult;
37046 }
37047
37048
37049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
37050   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37051   unsigned int arg2 ;
37052
37053   arg1 = (Dali::TapGestureDetector *)jarg1;
37054   arg2 = (unsigned int)jarg2;
37055   {
37056     try {
37057       (arg1)->SetMinimumTapsRequired(arg2);
37058     } catch (std::out_of_range& e) {
37059       {
37060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37061       };
37062     } catch (std::exception& e) {
37063       {
37064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37065       };
37066     } catch (...) {
37067       {
37068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37069       };
37070     }
37071   }
37072 }
37073
37074
37075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
37076   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37077   unsigned int arg2 ;
37078
37079   arg1 = (Dali::TapGestureDetector *)jarg1;
37080   arg2 = (unsigned int)jarg2;
37081   {
37082     try {
37083       (arg1)->SetMaximumTapsRequired(arg2);
37084     } catch (std::out_of_range& e) {
37085       {
37086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37087       };
37088     } catch (std::exception& e) {
37089       {
37090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37091       };
37092     } catch (...) {
37093       {
37094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37095       };
37096     }
37097   }
37098 }
37099
37100
37101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
37102   unsigned int jresult ;
37103   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37104   unsigned int result;
37105
37106   arg1 = (Dali::TapGestureDetector *)jarg1;
37107   {
37108     try {
37109       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
37110     } catch (std::out_of_range& e) {
37111       {
37112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37113       };
37114     } catch (std::exception& e) {
37115       {
37116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37117       };
37118     } catch (...) {
37119       {
37120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37121       };
37122     }
37123   }
37124   jresult = result;
37125   return jresult;
37126 }
37127
37128
37129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
37130   unsigned int jresult ;
37131   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37132   unsigned int result;
37133
37134   arg1 = (Dali::TapGestureDetector *)jarg1;
37135   {
37136     try {
37137       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
37138     } catch (std::out_of_range& e) {
37139       {
37140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37141       };
37142     } catch (std::exception& e) {
37143       {
37144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37145       };
37146     } catch (...) {
37147       {
37148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37149       };
37150     }
37151   }
37152   jresult = result;
37153   return jresult;
37154 }
37155
37156
37157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
37158   void * jresult ;
37159   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37160   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37161
37162   arg1 = (Dali::TapGestureDetector *)jarg1;
37163   {
37164     try {
37165       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37166     } catch (std::out_of_range& e) {
37167       {
37168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37169       };
37170     } catch (std::exception& e) {
37171       {
37172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37173       };
37174     } catch (...) {
37175       {
37176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37177       };
37178     }
37179   }
37180   jresult = (void *)result;
37181   return jresult;
37182 }
37183
37184
37185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37186   void * jresult ;
37187   Dali::TapGesture *result = 0 ;
37188
37189   {
37190     try {
37191       result = (Dali::TapGesture *)new Dali::TapGesture();
37192     } catch (std::out_of_range& e) {
37193       {
37194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37195       };
37196     } catch (std::exception& e) {
37197       {
37198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37199       };
37200     } catch (...) {
37201       {
37202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37203       };
37204     }
37205   }
37206   jresult = (void *)result;
37207   return jresult;
37208 }
37209
37210
37211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37212   void * jresult ;
37213   Dali::TapGesture *arg1 = 0 ;
37214   Dali::TapGesture *result = 0 ;
37215
37216   arg1 = (Dali::TapGesture *)jarg1;
37217   if (!arg1) {
37218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37219     return 0;
37220   }
37221   {
37222     try {
37223       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37224     } catch (std::out_of_range& e) {
37225       {
37226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37227       };
37228     } catch (std::exception& e) {
37229       {
37230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37231       };
37232     } catch (...) {
37233       {
37234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37235       };
37236     }
37237   }
37238   jresult = (void *)result;
37239   return jresult;
37240 }
37241
37242
37243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37244   void * jresult ;
37245   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37246   Dali::TapGesture *arg2 = 0 ;
37247   Dali::TapGesture *result = 0 ;
37248
37249   arg1 = (Dali::TapGesture *)jarg1;
37250   arg2 = (Dali::TapGesture *)jarg2;
37251   if (!arg2) {
37252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37253     return 0;
37254   }
37255   {
37256     try {
37257       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37258     } catch (std::out_of_range& e) {
37259       {
37260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37261       };
37262     } catch (std::exception& e) {
37263       {
37264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37265       };
37266     } catch (...) {
37267       {
37268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37269       };
37270     }
37271   }
37272   jresult = (void *)result;
37273   return jresult;
37274 }
37275
37276
37277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37278   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37279
37280   arg1 = (Dali::TapGesture *)jarg1;
37281   {
37282     try {
37283       delete arg1;
37284     } catch (std::out_of_range& e) {
37285       {
37286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37287       };
37288     } catch (std::exception& e) {
37289       {
37290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37291       };
37292     } catch (...) {
37293       {
37294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37295       };
37296     }
37297   }
37298 }
37299
37300
37301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37302   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37303   unsigned int arg2 ;
37304
37305   arg1 = (Dali::TapGesture *)jarg1;
37306   arg2 = (unsigned int)jarg2;
37307   if (arg1) (arg1)->numberOfTaps = arg2;
37308 }
37309
37310
37311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37312   unsigned int jresult ;
37313   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37314   unsigned int result;
37315
37316   arg1 = (Dali::TapGesture *)jarg1;
37317   result = (unsigned int) ((arg1)->numberOfTaps);
37318   jresult = result;
37319   return jresult;
37320 }
37321
37322
37323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37324   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37325   unsigned int arg2 ;
37326
37327   arg1 = (Dali::TapGesture *)jarg1;
37328   arg2 = (unsigned int)jarg2;
37329   if (arg1) (arg1)->numberOfTouches = arg2;
37330 }
37331
37332
37333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37334   unsigned int jresult ;
37335   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37336   unsigned int result;
37337
37338   arg1 = (Dali::TapGesture *)jarg1;
37339   result = (unsigned int) ((arg1)->numberOfTouches);
37340   jresult = result;
37341   return jresult;
37342 }
37343
37344
37345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37346   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37347   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37348
37349   arg1 = (Dali::TapGesture *)jarg1;
37350   arg2 = (Dali::Vector2 *)jarg2;
37351   if (arg1) (arg1)->screenPoint = *arg2;
37352 }
37353
37354
37355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37356   void * jresult ;
37357   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37358   Dali::Vector2 *result = 0 ;
37359
37360   arg1 = (Dali::TapGesture *)jarg1;
37361   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37362   jresult = (void *)result;
37363   return jresult;
37364 }
37365
37366
37367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37368   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37369   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37370
37371   arg1 = (Dali::TapGesture *)jarg1;
37372   arg2 = (Dali::Vector2 *)jarg2;
37373   if (arg1) (arg1)->localPoint = *arg2;
37374 }
37375
37376
37377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37378   void * jresult ;
37379   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37380   Dali::Vector2 *result = 0 ;
37381
37382   arg1 = (Dali::TapGesture *)jarg1;
37383   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37384   jresult = (void *)result;
37385   return jresult;
37386 }
37387
37388
37389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37390   void * jresult ;
37391   Dali::AlphaFunction *result = 0 ;
37392
37393   {
37394     try {
37395       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37396     } catch (std::out_of_range& e) {
37397       {
37398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37399       };
37400     } catch (std::exception& e) {
37401       {
37402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37403       };
37404     } catch (...) {
37405       {
37406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37407       };
37408     }
37409   }
37410   jresult = (void *)result;
37411   return jresult;
37412 }
37413
37414
37415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37416   void * jresult ;
37417   Dali::AlphaFunction::BuiltinFunction arg1 ;
37418   Dali::AlphaFunction *result = 0 ;
37419
37420   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37421   {
37422     try {
37423       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37424     } catch (std::out_of_range& e) {
37425       {
37426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37427       };
37428     } catch (std::exception& e) {
37429       {
37430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37431       };
37432     } catch (...) {
37433       {
37434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37435       };
37436     }
37437   }
37438   jresult = (void *)result;
37439   return jresult;
37440 }
37441
37442
37443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37444   void * jresult ;
37445   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37446   Dali::AlphaFunction *result = 0 ;
37447
37448   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37449   {
37450     try {
37451       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37452     } catch (std::out_of_range& e) {
37453       {
37454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37455       };
37456     } catch (std::exception& e) {
37457       {
37458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37459       };
37460     } catch (...) {
37461       {
37462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37463       };
37464     }
37465   }
37466   jresult = (void *)result;
37467   return jresult;
37468 }
37469
37470
37471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37472   void * jresult ;
37473   Dali::Vector2 *arg1 = 0 ;
37474   Dali::Vector2 *arg2 = 0 ;
37475   Dali::AlphaFunction *result = 0 ;
37476
37477   arg1 = (Dali::Vector2 *)jarg1;
37478   if (!arg1) {
37479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37480     return 0;
37481   }
37482   arg2 = (Dali::Vector2 *)jarg2;
37483   if (!arg2) {
37484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37485     return 0;
37486   }
37487   {
37488     try {
37489       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37490     } catch (std::out_of_range& e) {
37491       {
37492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37493       };
37494     } catch (std::exception& e) {
37495       {
37496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37497       };
37498     } catch (...) {
37499       {
37500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37501       };
37502     }
37503   }
37504   jresult = (void *)result;
37505   return jresult;
37506 }
37507
37508
37509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37510   void * jresult ;
37511   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37512   Dali::Vector4 result;
37513
37514   arg1 = (Dali::AlphaFunction *)jarg1;
37515   {
37516     try {
37517       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37518     } catch (std::out_of_range& e) {
37519       {
37520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37521       };
37522     } catch (std::exception& e) {
37523       {
37524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37525       };
37526     } catch (...) {
37527       {
37528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37529       };
37530     }
37531   }
37532   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37533   return jresult;
37534 }
37535
37536
37537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37538   void * jresult ;
37539   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37540   Dali::AlphaFunctionPrototype result;
37541
37542   arg1 = (Dali::AlphaFunction *)jarg1;
37543   {
37544     try {
37545       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37546     } catch (std::out_of_range& e) {
37547       {
37548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37549       };
37550     } catch (std::exception& e) {
37551       {
37552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37553       };
37554     } catch (...) {
37555       {
37556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37557       };
37558     }
37559   }
37560   jresult = (void *)result;
37561   return jresult;
37562 }
37563
37564
37565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37566   int jresult ;
37567   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37568   Dali::AlphaFunction::BuiltinFunction result;
37569
37570   arg1 = (Dali::AlphaFunction *)jarg1;
37571   {
37572     try {
37573       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37574     } catch (std::out_of_range& e) {
37575       {
37576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37577       };
37578     } catch (std::exception& e) {
37579       {
37580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37581       };
37582     } catch (...) {
37583       {
37584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37585       };
37586     }
37587   }
37588   jresult = (int)result;
37589   return jresult;
37590 }
37591
37592
37593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37594   int jresult ;
37595   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37596   Dali::AlphaFunction::Mode result;
37597
37598   arg1 = (Dali::AlphaFunction *)jarg1;
37599   {
37600     try {
37601       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37602     } catch (std::out_of_range& e) {
37603       {
37604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37605       };
37606     } catch (std::exception& e) {
37607       {
37608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37609       };
37610     } catch (...) {
37611       {
37612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37613       };
37614     }
37615   }
37616   jresult = (int)result;
37617   return jresult;
37618 }
37619
37620
37621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37622   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37623
37624   arg1 = (Dali::AlphaFunction *)jarg1;
37625   {
37626     try {
37627       delete arg1;
37628     } catch (std::out_of_range& e) {
37629       {
37630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37631       };
37632     } catch (std::exception& e) {
37633       {
37634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37635       };
37636     } catch (...) {
37637       {
37638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37639       };
37640     }
37641   }
37642 }
37643
37644
37645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37646   void * jresult ;
37647   Dali::KeyFrames result;
37648
37649   {
37650     try {
37651       result = Dali::KeyFrames::New();
37652     } catch (std::out_of_range& e) {
37653       {
37654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37655       };
37656     } catch (std::exception& e) {
37657       {
37658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37659       };
37660     } catch (...) {
37661       {
37662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37663       };
37664     }
37665   }
37666   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37667   return jresult;
37668 }
37669
37670
37671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37672   void * jresult ;
37673   Dali::BaseHandle arg1 ;
37674   Dali::BaseHandle *argp1 ;
37675   Dali::KeyFrames result;
37676
37677   argp1 = (Dali::BaseHandle *)jarg1;
37678   if (!argp1) {
37679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37680     return 0;
37681   }
37682   arg1 = *argp1;
37683   {
37684     try {
37685       result = Dali::KeyFrames::DownCast(arg1);
37686     } catch (std::out_of_range& e) {
37687       {
37688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37689       };
37690     } catch (std::exception& e) {
37691       {
37692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37693       };
37694     } catch (...) {
37695       {
37696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37697       };
37698     }
37699   }
37700   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37701   return jresult;
37702 }
37703
37704
37705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37706   void * jresult ;
37707   Dali::KeyFrames *result = 0 ;
37708
37709   {
37710     try {
37711       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37712     } catch (std::out_of_range& e) {
37713       {
37714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37715       };
37716     } catch (std::exception& e) {
37717       {
37718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37719       };
37720     } catch (...) {
37721       {
37722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37723       };
37724     }
37725   }
37726   jresult = (void *)result;
37727   return jresult;
37728 }
37729
37730
37731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37732   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37733
37734   arg1 = (Dali::KeyFrames *)jarg1;
37735   {
37736     try {
37737       delete arg1;
37738     } catch (std::out_of_range& e) {
37739       {
37740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37741       };
37742     } catch (std::exception& e) {
37743       {
37744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37745       };
37746     } catch (...) {
37747       {
37748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37749       };
37750     }
37751   }
37752 }
37753
37754
37755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37756   void * jresult ;
37757   Dali::KeyFrames *arg1 = 0 ;
37758   Dali::KeyFrames *result = 0 ;
37759
37760   arg1 = (Dali::KeyFrames *)jarg1;
37761   if (!arg1) {
37762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37763     return 0;
37764   }
37765   {
37766     try {
37767       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37768     } catch (std::out_of_range& e) {
37769       {
37770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37771       };
37772     } catch (std::exception& e) {
37773       {
37774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37775       };
37776     } catch (...) {
37777       {
37778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37779       };
37780     }
37781   }
37782   jresult = (void *)result;
37783   return jresult;
37784 }
37785
37786
37787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37788   void * jresult ;
37789   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37790   Dali::KeyFrames *arg2 = 0 ;
37791   Dali::KeyFrames *result = 0 ;
37792
37793   arg1 = (Dali::KeyFrames *)jarg1;
37794   arg2 = (Dali::KeyFrames *)jarg2;
37795   if (!arg2) {
37796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37797     return 0;
37798   }
37799   {
37800     try {
37801       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37802     } catch (std::out_of_range& e) {
37803       {
37804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37805       };
37806     } catch (std::exception& e) {
37807       {
37808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37809       };
37810     } catch (...) {
37811       {
37812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37813       };
37814     }
37815   }
37816   jresult = (void *)result;
37817   return jresult;
37818 }
37819
37820
37821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37822   int jresult ;
37823   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37824   Dali::Property::Type result;
37825
37826   arg1 = (Dali::KeyFrames *)jarg1;
37827   {
37828     try {
37829       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37830     } catch (std::out_of_range& e) {
37831       {
37832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37833       };
37834     } catch (std::exception& e) {
37835       {
37836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37837       };
37838     } catch (...) {
37839       {
37840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37841       };
37842     }
37843   }
37844   jresult = (int)result;
37845   return jresult;
37846 }
37847
37848
37849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37850   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37851   float arg2 ;
37852   Dali::Property::Value arg3 ;
37853   Dali::Property::Value *argp3 ;
37854
37855   arg1 = (Dali::KeyFrames *)jarg1;
37856   arg2 = (float)jarg2;
37857   argp3 = (Dali::Property::Value *)jarg3;
37858   if (!argp3) {
37859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37860     return ;
37861   }
37862   arg3 = *argp3;
37863   {
37864     try {
37865       (arg1)->Add(arg2,arg3);
37866     } catch (std::out_of_range& e) {
37867       {
37868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37869       };
37870     } catch (std::exception& e) {
37871       {
37872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37873       };
37874     } catch (...) {
37875       {
37876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37877       };
37878     }
37879   }
37880 }
37881
37882
37883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37884   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37885   float arg2 ;
37886   Dali::Property::Value arg3 ;
37887   Dali::AlphaFunction arg4 ;
37888   Dali::Property::Value *argp3 ;
37889   Dali::AlphaFunction *argp4 ;
37890
37891   arg1 = (Dali::KeyFrames *)jarg1;
37892   arg2 = (float)jarg2;
37893   argp3 = (Dali::Property::Value *)jarg3;
37894   if (!argp3) {
37895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37896     return ;
37897   }
37898   arg3 = *argp3;
37899   argp4 = (Dali::AlphaFunction *)jarg4;
37900   if (!argp4) {
37901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37902     return ;
37903   }
37904   arg4 = *argp4;
37905   {
37906     try {
37907       (arg1)->Add(arg2,arg3,arg4);
37908     } catch (std::out_of_range& e) {
37909       {
37910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37911       };
37912     } catch (std::exception& e) {
37913       {
37914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37915       };
37916     } catch (...) {
37917       {
37918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37919       };
37920     }
37921   }
37922 }
37923
37924
37925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37926   int jresult ;
37927   int result;
37928
37929   result = (int)Dali::Path::Property::POINTS;
37930   jresult = (int)result;
37931   return jresult;
37932 }
37933
37934
37935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37936   int jresult ;
37937   int result;
37938
37939   result = (int)Dali::Path::Property::CONTROL_POINTS;
37940   jresult = (int)result;
37941   return jresult;
37942 }
37943
37944
37945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37946   void * jresult ;
37947   Dali::Path::Property *result = 0 ;
37948
37949   {
37950     try {
37951       result = (Dali::Path::Property *)new Dali::Path::Property();
37952     } catch (std::out_of_range& e) {
37953       {
37954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37955       };
37956     } catch (std::exception& e) {
37957       {
37958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37959       };
37960     } catch (...) {
37961       {
37962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37963       };
37964     }
37965   }
37966   jresult = (void *)result;
37967   return jresult;
37968 }
37969
37970
37971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37972   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37973
37974   arg1 = (Dali::Path::Property *)jarg1;
37975   {
37976     try {
37977       delete arg1;
37978     } catch (std::out_of_range& e) {
37979       {
37980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37981       };
37982     } catch (std::exception& e) {
37983       {
37984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37985       };
37986     } catch (...) {
37987       {
37988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37989       };
37990     }
37991   }
37992 }
37993
37994
37995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
37996   void * jresult ;
37997   Dali::Path result;
37998
37999   {
38000     try {
38001       result = Dali::Path::New();
38002     } catch (std::out_of_range& e) {
38003       {
38004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38005       };
38006     } catch (std::exception& e) {
38007       {
38008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38009       };
38010     } catch (...) {
38011       {
38012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38013       };
38014     }
38015   }
38016   jresult = new Dali::Path((const Dali::Path &)result);
38017   return jresult;
38018 }
38019
38020
38021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
38022   void * jresult ;
38023   Dali::BaseHandle arg1 ;
38024   Dali::BaseHandle *argp1 ;
38025   Dali::Path result;
38026
38027   argp1 = (Dali::BaseHandle *)jarg1;
38028   if (!argp1) {
38029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38030     return 0;
38031   }
38032   arg1 = *argp1;
38033   {
38034     try {
38035       result = Dali::Path::DownCast(arg1);
38036     } catch (std::out_of_range& e) {
38037       {
38038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38039       };
38040     } catch (std::exception& e) {
38041       {
38042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38043       };
38044     } catch (...) {
38045       {
38046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38047       };
38048     }
38049   }
38050   jresult = new Dali::Path((const Dali::Path &)result);
38051   return jresult;
38052 }
38053
38054
38055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
38056   void * jresult ;
38057   Dali::Path *result = 0 ;
38058
38059   {
38060     try {
38061       result = (Dali::Path *)new Dali::Path();
38062     } catch (std::out_of_range& e) {
38063       {
38064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38065       };
38066     } catch (std::exception& e) {
38067       {
38068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38069       };
38070     } catch (...) {
38071       {
38072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38073       };
38074     }
38075   }
38076   jresult = (void *)result;
38077   return jresult;
38078 }
38079
38080
38081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
38082   Dali::Path *arg1 = (Dali::Path *) 0 ;
38083
38084   arg1 = (Dali::Path *)jarg1;
38085   {
38086     try {
38087       delete arg1;
38088     } catch (std::out_of_range& e) {
38089       {
38090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38091       };
38092     } catch (std::exception& e) {
38093       {
38094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38095       };
38096     } catch (...) {
38097       {
38098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38099       };
38100     }
38101   }
38102 }
38103
38104
38105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
38106   void * jresult ;
38107   Dali::Path *arg1 = 0 ;
38108   Dali::Path *result = 0 ;
38109
38110   arg1 = (Dali::Path *)jarg1;
38111   if (!arg1) {
38112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38113     return 0;
38114   }
38115   {
38116     try {
38117       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
38118     } catch (std::out_of_range& e) {
38119       {
38120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38121       };
38122     } catch (std::exception& e) {
38123       {
38124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38125       };
38126     } catch (...) {
38127       {
38128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38129       };
38130     }
38131   }
38132   jresult = (void *)result;
38133   return jresult;
38134 }
38135
38136
38137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
38138   void * jresult ;
38139   Dali::Path *arg1 = (Dali::Path *) 0 ;
38140   Dali::Path *arg2 = 0 ;
38141   Dali::Path *result = 0 ;
38142
38143   arg1 = (Dali::Path *)jarg1;
38144   arg2 = (Dali::Path *)jarg2;
38145   if (!arg2) {
38146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38147     return 0;
38148   }
38149   {
38150     try {
38151       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
38152     } catch (std::out_of_range& e) {
38153       {
38154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38155       };
38156     } catch (std::exception& e) {
38157       {
38158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38159       };
38160     } catch (...) {
38161       {
38162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38163       };
38164     }
38165   }
38166   jresult = (void *)result;
38167   return jresult;
38168 }
38169
38170
38171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38172   Dali::Path *arg1 = (Dali::Path *) 0 ;
38173   Dali::Vector3 *arg2 = 0 ;
38174
38175   arg1 = (Dali::Path *)jarg1;
38176   arg2 = (Dali::Vector3 *)jarg2;
38177   if (!arg2) {
38178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38179     return ;
38180   }
38181   {
38182     try {
38183       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38184     } catch (std::out_of_range& e) {
38185       {
38186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38187       };
38188     } catch (std::exception& e) {
38189       {
38190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38191       };
38192     } catch (...) {
38193       {
38194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38195       };
38196     }
38197   }
38198 }
38199
38200
38201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38202   Dali::Path *arg1 = (Dali::Path *) 0 ;
38203   Dali::Vector3 *arg2 = 0 ;
38204
38205   arg1 = (Dali::Path *)jarg1;
38206   arg2 = (Dali::Vector3 *)jarg2;
38207   if (!arg2) {
38208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38209     return ;
38210   }
38211   {
38212     try {
38213       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38214     } catch (std::out_of_range& e) {
38215       {
38216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38217       };
38218     } catch (std::exception& e) {
38219       {
38220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38221       };
38222     } catch (...) {
38223       {
38224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38225       };
38226     }
38227   }
38228 }
38229
38230
38231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38232   Dali::Path *arg1 = (Dali::Path *) 0 ;
38233   float arg2 ;
38234
38235   arg1 = (Dali::Path *)jarg1;
38236   arg2 = (float)jarg2;
38237   {
38238     try {
38239       (arg1)->GenerateControlPoints(arg2);
38240     } catch (std::out_of_range& e) {
38241       {
38242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38243       };
38244     } catch (std::exception& e) {
38245       {
38246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38247       };
38248     } catch (...) {
38249       {
38250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38251       };
38252     }
38253   }
38254 }
38255
38256
38257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38258   Dali::Path *arg1 = (Dali::Path *) 0 ;
38259   float arg2 ;
38260   Dali::Vector3 *arg3 = 0 ;
38261   Dali::Vector3 *arg4 = 0 ;
38262
38263   arg1 = (Dali::Path *)jarg1;
38264   arg2 = (float)jarg2;
38265   arg3 = (Dali::Vector3 *)jarg3;
38266   if (!arg3) {
38267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38268     return ;
38269   }
38270   arg4 = (Dali::Vector3 *)jarg4;
38271   if (!arg4) {
38272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38273     return ;
38274   }
38275   {
38276     try {
38277       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38278     } catch (std::out_of_range& e) {
38279       {
38280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38281       };
38282     } catch (std::exception& e) {
38283       {
38284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38285       };
38286     } catch (...) {
38287       {
38288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38289       };
38290     }
38291   }
38292 }
38293
38294
38295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38296   void * jresult ;
38297   Dali::Path *arg1 = (Dali::Path *) 0 ;
38298   size_t arg2 ;
38299   Dali::Vector3 *result = 0 ;
38300
38301   arg1 = (Dali::Path *)jarg1;
38302   arg2 = (size_t)jarg2;
38303   {
38304     try {
38305       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38306     } catch (std::out_of_range& e) {
38307       {
38308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38309       };
38310     } catch (std::exception& e) {
38311       {
38312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38313       };
38314     } catch (...) {
38315       {
38316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38317       };
38318     }
38319   }
38320   jresult = (void *)result;
38321   return jresult;
38322 }
38323
38324
38325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38326   void * jresult ;
38327   Dali::Path *arg1 = (Dali::Path *) 0 ;
38328   size_t arg2 ;
38329   Dali::Vector3 *result = 0 ;
38330
38331   arg1 = (Dali::Path *)jarg1;
38332   arg2 = (size_t)jarg2;
38333   {
38334     try {
38335       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38336     } catch (std::out_of_range& e) {
38337       {
38338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38339       };
38340     } catch (std::exception& e) {
38341       {
38342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38343       };
38344     } catch (...) {
38345       {
38346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38347       };
38348     }
38349   }
38350   jresult = (void *)result;
38351   return jresult;
38352 }
38353
38354
38355 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38356   unsigned long jresult ;
38357   Dali::Path *arg1 = (Dali::Path *) 0 ;
38358   size_t result;
38359
38360   arg1 = (Dali::Path *)jarg1;
38361   {
38362     try {
38363       result = ((Dali::Path const *)arg1)->GetPointCount();
38364     } catch (std::out_of_range& e) {
38365       {
38366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38367       };
38368     } catch (std::exception& e) {
38369       {
38370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38371       };
38372     } catch (...) {
38373       {
38374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38375       };
38376     }
38377   }
38378   jresult = (unsigned long)result;
38379   return jresult;
38380 }
38381
38382
38383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38384   void * jresult ;
38385   float arg1 ;
38386   Dali::TimePeriod *result = 0 ;
38387
38388   arg1 = (float)jarg1;
38389   {
38390     try {
38391       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38392     } catch (std::out_of_range& e) {
38393       {
38394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38395       };
38396     } catch (std::exception& e) {
38397       {
38398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38399       };
38400     } catch (...) {
38401       {
38402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38403       };
38404     }
38405   }
38406   jresult = (void *)result;
38407   return jresult;
38408 }
38409
38410
38411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38412   void * jresult ;
38413   float arg1 ;
38414   float arg2 ;
38415   Dali::TimePeriod *result = 0 ;
38416
38417   arg1 = (float)jarg1;
38418   arg2 = (float)jarg2;
38419   {
38420     try {
38421       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38422     } catch (std::out_of_range& e) {
38423       {
38424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38425       };
38426     } catch (std::exception& e) {
38427       {
38428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38429       };
38430     } catch (...) {
38431       {
38432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38433       };
38434     }
38435   }
38436   jresult = (void *)result;
38437   return jresult;
38438 }
38439
38440
38441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38442   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38443
38444   arg1 = (Dali::TimePeriod *)jarg1;
38445   {
38446     try {
38447       delete arg1;
38448     } catch (std::out_of_range& e) {
38449       {
38450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38451       };
38452     } catch (std::exception& e) {
38453       {
38454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38455       };
38456     } catch (...) {
38457       {
38458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38459       };
38460     }
38461   }
38462 }
38463
38464
38465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38466   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38467   float arg2 ;
38468
38469   arg1 = (Dali::TimePeriod *)jarg1;
38470   arg2 = (float)jarg2;
38471   if (arg1) (arg1)->delaySeconds = arg2;
38472 }
38473
38474
38475 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38476   float jresult ;
38477   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38478   float result;
38479
38480   arg1 = (Dali::TimePeriod *)jarg1;
38481   result = (float) ((arg1)->delaySeconds);
38482   jresult = result;
38483   return jresult;
38484 }
38485
38486
38487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38488   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38489   float arg2 ;
38490
38491   arg1 = (Dali::TimePeriod *)jarg1;
38492   arg2 = (float)jarg2;
38493   if (arg1) (arg1)->durationSeconds = arg2;
38494 }
38495
38496
38497 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38498   float jresult ;
38499   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38500   float result;
38501
38502   arg1 = (Dali::TimePeriod *)jarg1;
38503   result = (float) ((arg1)->durationSeconds);
38504   jresult = result;
38505   return jresult;
38506 }
38507
38508
38509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
38510   void * jresult ;
38511   Dali::Animation *result = 0 ;
38512
38513   {
38514     try {
38515       result = (Dali::Animation *)new Dali::Animation();
38516     } catch (std::out_of_range& e) {
38517       {
38518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38519       };
38520     } catch (std::exception& e) {
38521       {
38522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38523       };
38524     } catch (...) {
38525       {
38526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38527       };
38528     }
38529   }
38530   jresult = (void *)result;
38531   return jresult;
38532 }
38533
38534
38535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
38536   void * jresult ;
38537   float arg1 ;
38538   Dali::Animation result;
38539
38540   arg1 = (float)jarg1;
38541   {
38542     try {
38543       result = Dali::Animation::New(arg1);
38544     } catch (std::out_of_range& e) {
38545       {
38546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38547       };
38548     } catch (std::exception& e) {
38549       {
38550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38551       };
38552     } catch (...) {
38553       {
38554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38555       };
38556     }
38557   }
38558   jresult = new Dali::Animation((const Dali::Animation &)result);
38559   return jresult;
38560 }
38561
38562
38563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
38564   void * jresult ;
38565   Dali::BaseHandle arg1 ;
38566   Dali::BaseHandle *argp1 ;
38567   Dali::Animation result;
38568
38569   argp1 = (Dali::BaseHandle *)jarg1;
38570   if (!argp1) {
38571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38572     return 0;
38573   }
38574   arg1 = *argp1;
38575   {
38576     try {
38577       result = Dali::Animation::DownCast(arg1);
38578     } catch (std::out_of_range& e) {
38579       {
38580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38581       };
38582     } catch (std::exception& e) {
38583       {
38584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38585       };
38586     } catch (...) {
38587       {
38588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38589       };
38590     }
38591   }
38592   jresult = new Dali::Animation((const Dali::Animation &)result);
38593   return jresult;
38594 }
38595
38596
38597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
38598   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38599
38600   arg1 = (Dali::Animation *)jarg1;
38601   {
38602     try {
38603       delete arg1;
38604     } catch (std::out_of_range& e) {
38605       {
38606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38607       };
38608     } catch (std::exception& e) {
38609       {
38610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38611       };
38612     } catch (...) {
38613       {
38614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38615       };
38616     }
38617   }
38618 }
38619
38620
38621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
38622   void * jresult ;
38623   Dali::Animation *arg1 = 0 ;
38624   Dali::Animation *result = 0 ;
38625
38626   arg1 = (Dali::Animation *)jarg1;
38627   if (!arg1) {
38628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38629     return 0;
38630   }
38631   {
38632     try {
38633       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
38634     } catch (std::out_of_range& e) {
38635       {
38636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38637       };
38638     } catch (std::exception& e) {
38639       {
38640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38641       };
38642     } catch (...) {
38643       {
38644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38645       };
38646     }
38647   }
38648   jresult = (void *)result;
38649   return jresult;
38650 }
38651
38652
38653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) {
38654   void * jresult ;
38655   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38656   Dali::Animation *arg2 = 0 ;
38657   Dali::Animation *result = 0 ;
38658
38659   arg1 = (Dali::Animation *)jarg1;
38660   arg2 = (Dali::Animation *)jarg2;
38661   if (!arg2) {
38662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38663     return 0;
38664   }
38665   {
38666     try {
38667       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
38668     } catch (std::out_of_range& e) {
38669       {
38670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38671       };
38672     } catch (std::exception& e) {
38673       {
38674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38675       };
38676     } catch (...) {
38677       {
38678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38679       };
38680     }
38681   }
38682   jresult = (void *)result;
38683   return jresult;
38684 }
38685
38686
38687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
38688   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38689   float arg2 ;
38690
38691   arg1 = (Dali::Animation *)jarg1;
38692   arg2 = (float)jarg2;
38693   {
38694     try {
38695       (arg1)->SetDuration(arg2);
38696     } catch (std::out_of_range& e) {
38697       {
38698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38699       };
38700     } catch (std::exception& e) {
38701       {
38702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38703       };
38704     } catch (...) {
38705       {
38706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38707       };
38708     }
38709   }
38710 }
38711
38712
38713 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
38714   float jresult ;
38715   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38716   float result;
38717
38718   arg1 = (Dali::Animation *)jarg1;
38719   {
38720     try {
38721       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38722     } catch (std::out_of_range& e) {
38723       {
38724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38725       };
38726     } catch (std::exception& e) {
38727       {
38728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38729       };
38730     } catch (...) {
38731       {
38732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38733       };
38734     }
38735   }
38736   jresult = result;
38737   return jresult;
38738 }
38739
38740
38741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38742   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38743   bool arg2 ;
38744
38745   arg1 = (Dali::Animation *)jarg1;
38746   arg2 = jarg2 ? true : false;
38747   {
38748     try {
38749       (arg1)->SetLooping(arg2);
38750     } catch (std::out_of_range& e) {
38751       {
38752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38753       };
38754     } catch (std::exception& e) {
38755       {
38756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38757       };
38758     } catch (...) {
38759       {
38760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38761       };
38762     }
38763   }
38764 }
38765
38766
38767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
38768   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38769   int arg2 ;
38770
38771   arg1 = (Dali::Animation *)jarg1;
38772   arg2 = (int)jarg2;
38773   {
38774     try {
38775       (arg1)->SetLoopCount(arg2);
38776     } catch (std::out_of_range& e) {
38777       {
38778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38779       };
38780     } catch (std::exception& e) {
38781       {
38782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38783       };
38784     } catch (...) {
38785       {
38786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38787       };
38788     }
38789   }
38790 }
38791
38792
38793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
38794   int jresult ;
38795   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38796   int result;
38797
38798   arg1 = (Dali::Animation *)jarg1;
38799   {
38800     try {
38801       result = (int)(arg1)->GetLoopCount();
38802     } catch (std::out_of_range& e) {
38803       {
38804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38805       };
38806     } catch (std::exception& e) {
38807       {
38808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38809       };
38810     } catch (...) {
38811       {
38812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38813       };
38814     }
38815   }
38816   jresult = result;
38817   return jresult;
38818 }
38819
38820
38821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
38822   int jresult ;
38823   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38824   int result;
38825
38826   arg1 = (Dali::Animation *)jarg1;
38827   {
38828     try {
38829       result = (int)(arg1)->GetCurrentLoop();
38830     } catch (std::out_of_range& e) {
38831       {
38832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38833       };
38834     } catch (std::exception& e) {
38835       {
38836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38837       };
38838     } catch (...) {
38839       {
38840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38841       };
38842     }
38843   }
38844   jresult = result;
38845   return jresult;
38846 }
38847
38848
38849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
38850   unsigned int jresult ;
38851   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38852   bool result;
38853
38854   arg1 = (Dali::Animation *)jarg1;
38855   {
38856     try {
38857       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38858     } catch (std::out_of_range& e) {
38859       {
38860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38861       };
38862     } catch (std::exception& e) {
38863       {
38864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38865       };
38866     } catch (...) {
38867       {
38868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38869       };
38870     }
38871   }
38872   jresult = result;
38873   return jresult;
38874 }
38875
38876
38877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
38878   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38879   Dali::Animation::EndAction arg2 ;
38880
38881   arg1 = (Dali::Animation *)jarg1;
38882   arg2 = (Dali::Animation::EndAction)jarg2;
38883   {
38884     try {
38885       (arg1)->SetEndAction(arg2);
38886     } catch (std::out_of_range& e) {
38887       {
38888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38889       };
38890     } catch (std::exception& e) {
38891       {
38892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38893       };
38894     } catch (...) {
38895       {
38896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38897       };
38898     }
38899   }
38900 }
38901
38902
38903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
38904   int jresult ;
38905   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38906   Dali::Animation::EndAction result;
38907
38908   arg1 = (Dali::Animation *)jarg1;
38909   {
38910     try {
38911       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38912     } catch (std::out_of_range& e) {
38913       {
38914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38915       };
38916     } catch (std::exception& e) {
38917       {
38918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38919       };
38920     } catch (...) {
38921       {
38922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38923       };
38924     }
38925   }
38926   jresult = (int)result;
38927   return jresult;
38928 }
38929
38930
38931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
38932   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38933   Dali::Animation::EndAction arg2 ;
38934
38935   arg1 = (Dali::Animation *)jarg1;
38936   arg2 = (Dali::Animation::EndAction)jarg2;
38937   {
38938     try {
38939       (arg1)->SetDisconnectAction(arg2);
38940     } catch (std::out_of_range& e) {
38941       {
38942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38943       };
38944     } catch (std::exception& e) {
38945       {
38946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38947       };
38948     } catch (...) {
38949       {
38950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38951       };
38952     }
38953   }
38954 }
38955
38956
38957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
38958   int jresult ;
38959   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38960   Dali::Animation::EndAction result;
38961
38962   arg1 = (Dali::Animation *)jarg1;
38963   {
38964     try {
38965       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
38966     } catch (std::out_of_range& e) {
38967       {
38968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38969       };
38970     } catch (std::exception& e) {
38971       {
38972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38973       };
38974     } catch (...) {
38975       {
38976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38977       };
38978     }
38979   }
38980   jresult = (int)result;
38981   return jresult;
38982 }
38983
38984
38985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
38986   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38987   Dali::AlphaFunction arg2 ;
38988   Dali::AlphaFunction *argp2 ;
38989
38990   arg1 = (Dali::Animation *)jarg1;
38991   argp2 = (Dali::AlphaFunction *)jarg2;
38992   if (!argp2) {
38993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
38994     return ;
38995   }
38996   arg2 = *argp2;
38997   {
38998     try {
38999       (arg1)->SetDefaultAlphaFunction(arg2);
39000     } catch (std::out_of_range& e) {
39001       {
39002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39003       };
39004     } catch (std::exception& e) {
39005       {
39006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39007       };
39008     } catch (...) {
39009       {
39010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39011       };
39012     }
39013   }
39014 }
39015
39016
39017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
39018   void * jresult ;
39019   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39020   Dali::AlphaFunction result;
39021
39022   arg1 = (Dali::Animation *)jarg1;
39023   {
39024     try {
39025       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
39026     } catch (std::out_of_range& e) {
39027       {
39028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39029       };
39030     } catch (std::exception& e) {
39031       {
39032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39033       };
39034     } catch (...) {
39035       {
39036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39037       };
39038     }
39039   }
39040   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
39041   return jresult;
39042 }
39043
39044
39045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
39046   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39047   float arg2 ;
39048
39049   arg1 = (Dali::Animation *)jarg1;
39050   arg2 = (float)jarg2;
39051   {
39052     try {
39053       (arg1)->SetCurrentProgress(arg2);
39054     } catch (std::out_of_range& e) {
39055       {
39056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39057       };
39058     } catch (std::exception& e) {
39059       {
39060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39061       };
39062     } catch (...) {
39063       {
39064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39065       };
39066     }
39067   }
39068 }
39069
39070
39071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
39072   float jresult ;
39073   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39074   float result;
39075
39076   arg1 = (Dali::Animation *)jarg1;
39077   {
39078     try {
39079       result = (float)(arg1)->GetCurrentProgress();
39080     } catch (std::out_of_range& e) {
39081       {
39082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39083       };
39084     } catch (std::exception& e) {
39085       {
39086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39087       };
39088     } catch (...) {
39089       {
39090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39091       };
39092     }
39093   }
39094   jresult = result;
39095   return jresult;
39096 }
39097
39098
39099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
39100   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39101   float arg2 ;
39102
39103   arg1 = (Dali::Animation *)jarg1;
39104   arg2 = (float)jarg2;
39105   {
39106     try {
39107       (arg1)->SetSpeedFactor(arg2);
39108     } catch (std::out_of_range& e) {
39109       {
39110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39111       };
39112     } catch (std::exception& e) {
39113       {
39114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39115       };
39116     } catch (...) {
39117       {
39118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39119       };
39120     }
39121   }
39122 }
39123
39124
39125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
39126   float jresult ;
39127   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39128   float result;
39129
39130   arg1 = (Dali::Animation *)jarg1;
39131   {
39132     try {
39133       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
39134     } catch (std::out_of_range& e) {
39135       {
39136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39137       };
39138     } catch (std::exception& e) {
39139       {
39140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39141       };
39142     } catch (...) {
39143       {
39144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39145       };
39146     }
39147   }
39148   jresult = result;
39149   return jresult;
39150 }
39151
39152
39153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
39154   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39155   Dali::Vector2 *arg2 = 0 ;
39156
39157   arg1 = (Dali::Animation *)jarg1;
39158   arg2 = (Dali::Vector2 *)jarg2;
39159   if (!arg2) {
39160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39161     return ;
39162   }
39163   {
39164     try {
39165       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
39166     } catch (std::out_of_range& e) {
39167       {
39168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39169       };
39170     } catch (std::exception& e) {
39171       {
39172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39173       };
39174     } catch (...) {
39175       {
39176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39177       };
39178     }
39179   }
39180 }
39181
39182
39183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
39184   void * jresult ;
39185   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39186   Dali::Vector2 result;
39187
39188   arg1 = (Dali::Animation *)jarg1;
39189   {
39190     try {
39191       result = ((Dali::Animation const *)arg1)->GetPlayRange();
39192     } catch (std::out_of_range& e) {
39193       {
39194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39195       };
39196     } catch (std::exception& e) {
39197       {
39198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39199       };
39200     } catch (...) {
39201       {
39202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39203       };
39204     }
39205   }
39206   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
39207   return jresult;
39208 }
39209
39210
39211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
39212   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39213
39214   arg1 = (Dali::Animation *)jarg1;
39215   {
39216     try {
39217       (arg1)->Play();
39218     } catch (std::out_of_range& e) {
39219       {
39220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39221       };
39222     } catch (std::exception& e) {
39223       {
39224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39225       };
39226     } catch (...) {
39227       {
39228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39229       };
39230     }
39231   }
39232 }
39233
39234
39235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
39236   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39237   float arg2 ;
39238
39239   arg1 = (Dali::Animation *)jarg1;
39240   arg2 = (float)jarg2;
39241   {
39242     try {
39243       (arg1)->PlayFrom(arg2);
39244     } catch (std::out_of_range& e) {
39245       {
39246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39247       };
39248     } catch (std::exception& e) {
39249       {
39250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39251       };
39252     } catch (...) {
39253       {
39254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39255       };
39256     }
39257   }
39258 }
39259
39260
39261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
39262   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39263
39264   arg1 = (Dali::Animation *)jarg1;
39265   {
39266     try {
39267       (arg1)->Pause();
39268     } catch (std::out_of_range& e) {
39269       {
39270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39271       };
39272     } catch (std::exception& e) {
39273       {
39274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39275       };
39276     } catch (...) {
39277       {
39278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39279       };
39280     }
39281   }
39282 }
39283
39284
39285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
39286   int jresult ;
39287   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39288   Dali::Animation::State result;
39289
39290   arg1 = (Dali::Animation *)jarg1;
39291   {
39292     try {
39293       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
39294     } catch (std::out_of_range& e) {
39295       {
39296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39297       };
39298     } catch (std::exception& e) {
39299       {
39300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39301       };
39302     } catch (...) {
39303       {
39304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39305       };
39306     }
39307   }
39308   jresult = (int)result;
39309   return jresult;
39310 }
39311
39312
39313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
39314   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39315
39316   arg1 = (Dali::Animation *)jarg1;
39317   {
39318     try {
39319       (arg1)->Stop();
39320     } catch (std::out_of_range& e) {
39321       {
39322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39323       };
39324     } catch (std::exception& e) {
39325       {
39326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39327       };
39328     } catch (...) {
39329       {
39330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39331       };
39332     }
39333   }
39334 }
39335
39336
39337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
39338   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39339
39340   arg1 = (Dali::Animation *)jarg1;
39341   {
39342     try {
39343       (arg1)->Clear();
39344     } catch (std::out_of_range& e) {
39345       {
39346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39347       };
39348     } catch (std::exception& e) {
39349       {
39350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39351       };
39352     } catch (...) {
39353       {
39354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39355       };
39356     }
39357   }
39358 }
39359
39360
39361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
39362   void * jresult ;
39363   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39364   Dali::Animation::AnimationSignalType *result = 0 ;
39365
39366   arg1 = (Dali::Animation *)jarg1;
39367   {
39368     try {
39369       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
39370     } catch (std::out_of_range& e) {
39371       {
39372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39373       };
39374     } catch (std::exception& e) {
39375       {
39376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39377       };
39378     } catch (...) {
39379       {
39380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39381       };
39382     }
39383   }
39384   jresult = (void *)result;
39385   return jresult;
39386 }
39387
39388
39389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39390   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39391   SwigValueWrapper< Dali::Property > arg2 ;
39392   Dali::Property::Value arg3 ;
39393   Dali::Property *argp2 ;
39394   Dali::Property::Value *argp3 ;
39395
39396   arg1 = (Dali::Animation *)jarg1;
39397   argp2 = (Dali::Property *)jarg2;
39398   if (!argp2) {
39399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39400     return ;
39401   }
39402   arg2 = *argp2;
39403   argp3 = (Dali::Property::Value *)jarg3;
39404   if (!argp3) {
39405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39406     return ;
39407   }
39408   arg3 = *argp3;
39409   {
39410     try {
39411       (arg1)->AnimateBy(arg2,arg3);
39412     } catch (std::out_of_range& e) {
39413       {
39414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39415       };
39416     } catch (std::exception& e) {
39417       {
39418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39419       };
39420     } catch (...) {
39421       {
39422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39423       };
39424     }
39425   }
39426 }
39427
39428
39429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39430   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39431   SwigValueWrapper< Dali::Property > arg2 ;
39432   Dali::Property::Value arg3 ;
39433   Dali::AlphaFunction arg4 ;
39434   Dali::Property *argp2 ;
39435   Dali::Property::Value *argp3 ;
39436   Dali::AlphaFunction *argp4 ;
39437
39438   arg1 = (Dali::Animation *)jarg1;
39439   argp2 = (Dali::Property *)jarg2;
39440   if (!argp2) {
39441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39442     return ;
39443   }
39444   arg2 = *argp2;
39445   argp3 = (Dali::Property::Value *)jarg3;
39446   if (!argp3) {
39447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39448     return ;
39449   }
39450   arg3 = *argp3;
39451   argp4 = (Dali::AlphaFunction *)jarg4;
39452   if (!argp4) {
39453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39454     return ;
39455   }
39456   arg4 = *argp4;
39457   {
39458     try {
39459       (arg1)->AnimateBy(arg2,arg3,arg4);
39460     } catch (std::out_of_range& e) {
39461       {
39462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39463       };
39464     } catch (std::exception& e) {
39465       {
39466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39467       };
39468     } catch (...) {
39469       {
39470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39471       };
39472     }
39473   }
39474 }
39475
39476
39477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39478   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39479   SwigValueWrapper< Dali::Property > arg2 ;
39480   Dali::Property::Value arg3 ;
39481   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39482   Dali::Property *argp2 ;
39483   Dali::Property::Value *argp3 ;
39484   Dali::TimePeriod *argp4 ;
39485
39486   arg1 = (Dali::Animation *)jarg1;
39487   argp2 = (Dali::Property *)jarg2;
39488   if (!argp2) {
39489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39490     return ;
39491   }
39492   arg2 = *argp2;
39493   argp3 = (Dali::Property::Value *)jarg3;
39494   if (!argp3) {
39495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39496     return ;
39497   }
39498   arg3 = *argp3;
39499   argp4 = (Dali::TimePeriod *)jarg4;
39500   if (!argp4) {
39501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39502     return ;
39503   }
39504   arg4 = *argp4;
39505   {
39506     try {
39507       (arg1)->AnimateBy(arg2,arg3,arg4);
39508     } catch (std::out_of_range& e) {
39509       {
39510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39511       };
39512     } catch (std::exception& e) {
39513       {
39514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39515       };
39516     } catch (...) {
39517       {
39518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39519       };
39520     }
39521   }
39522 }
39523
39524
39525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39526   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39527   SwigValueWrapper< Dali::Property > arg2 ;
39528   Dali::Property::Value arg3 ;
39529   Dali::AlphaFunction arg4 ;
39530   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39531   Dali::Property *argp2 ;
39532   Dali::Property::Value *argp3 ;
39533   Dali::AlphaFunction *argp4 ;
39534   Dali::TimePeriod *argp5 ;
39535
39536   arg1 = (Dali::Animation *)jarg1;
39537   argp2 = (Dali::Property *)jarg2;
39538   if (!argp2) {
39539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39540     return ;
39541   }
39542   arg2 = *argp2;
39543   argp3 = (Dali::Property::Value *)jarg3;
39544   if (!argp3) {
39545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39546     return ;
39547   }
39548   arg3 = *argp3;
39549   argp4 = (Dali::AlphaFunction *)jarg4;
39550   if (!argp4) {
39551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39552     return ;
39553   }
39554   arg4 = *argp4;
39555   argp5 = (Dali::TimePeriod *)jarg5;
39556   if (!argp5) {
39557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39558     return ;
39559   }
39560   arg5 = *argp5;
39561   {
39562     try {
39563       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39564     } catch (std::out_of_range& e) {
39565       {
39566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39567       };
39568     } catch (std::exception& e) {
39569       {
39570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39571       };
39572     } catch (...) {
39573       {
39574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39575       };
39576     }
39577   }
39578 }
39579
39580
39581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39582   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39583   SwigValueWrapper< Dali::Property > arg2 ;
39584   Dali::Property::Value arg3 ;
39585   Dali::Property *argp2 ;
39586   Dali::Property::Value *argp3 ;
39587
39588   arg1 = (Dali::Animation *)jarg1;
39589   argp2 = (Dali::Property *)jarg2;
39590   if (!argp2) {
39591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39592     return ;
39593   }
39594   arg2 = *argp2;
39595   argp3 = (Dali::Property::Value *)jarg3;
39596   if (!argp3) {
39597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39598     return ;
39599   }
39600   arg3 = *argp3;
39601   {
39602     try {
39603       (arg1)->AnimateTo(arg2,arg3);
39604     } catch (std::out_of_range& e) {
39605       {
39606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39607       };
39608     } catch (std::exception& e) {
39609       {
39610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39611       };
39612     } catch (...) {
39613       {
39614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39615       };
39616     }
39617   }
39618 }
39619
39620
39621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39622   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39623   SwigValueWrapper< Dali::Property > arg2 ;
39624   Dali::Property::Value arg3 ;
39625   Dali::AlphaFunction arg4 ;
39626   Dali::Property *argp2 ;
39627   Dali::Property::Value *argp3 ;
39628   Dali::AlphaFunction *argp4 ;
39629
39630   arg1 = (Dali::Animation *)jarg1;
39631   argp2 = (Dali::Property *)jarg2;
39632   if (!argp2) {
39633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39634     return ;
39635   }
39636   arg2 = *argp2;
39637   argp3 = (Dali::Property::Value *)jarg3;
39638   if (!argp3) {
39639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39640     return ;
39641   }
39642   arg3 = *argp3;
39643   argp4 = (Dali::AlphaFunction *)jarg4;
39644   if (!argp4) {
39645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39646     return ;
39647   }
39648   arg4 = *argp4;
39649   {
39650     try {
39651       (arg1)->AnimateTo(arg2,arg3,arg4);
39652     } catch (std::out_of_range& e) {
39653       {
39654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39655       };
39656     } catch (std::exception& e) {
39657       {
39658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39659       };
39660     } catch (...) {
39661       {
39662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39663       };
39664     }
39665   }
39666 }
39667
39668
39669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39670   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39671   SwigValueWrapper< Dali::Property > arg2 ;
39672   Dali::Property::Value arg3 ;
39673   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39674   Dali::Property *argp2 ;
39675   Dali::Property::Value *argp3 ;
39676   Dali::TimePeriod *argp4 ;
39677
39678   arg1 = (Dali::Animation *)jarg1;
39679   argp2 = (Dali::Property *)jarg2;
39680   if (!argp2) {
39681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39682     return ;
39683   }
39684   arg2 = *argp2;
39685   argp3 = (Dali::Property::Value *)jarg3;
39686   if (!argp3) {
39687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39688     return ;
39689   }
39690   arg3 = *argp3;
39691   argp4 = (Dali::TimePeriod *)jarg4;
39692   if (!argp4) {
39693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39694     return ;
39695   }
39696   arg4 = *argp4;
39697   {
39698     try {
39699       (arg1)->AnimateTo(arg2,arg3,arg4);
39700     } catch (std::out_of_range& e) {
39701       {
39702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39703       };
39704     } catch (std::exception& e) {
39705       {
39706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39707       };
39708     } catch (...) {
39709       {
39710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39711       };
39712     }
39713   }
39714 }
39715
39716
39717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39718   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39719   SwigValueWrapper< Dali::Property > arg2 ;
39720   Dali::Property::Value arg3 ;
39721   Dali::AlphaFunction arg4 ;
39722   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39723   Dali::Property *argp2 ;
39724   Dali::Property::Value *argp3 ;
39725   Dali::AlphaFunction *argp4 ;
39726   Dali::TimePeriod *argp5 ;
39727
39728   arg1 = (Dali::Animation *)jarg1;
39729   argp2 = (Dali::Property *)jarg2;
39730   if (!argp2) {
39731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39732     return ;
39733   }
39734   arg2 = *argp2;
39735   argp3 = (Dali::Property::Value *)jarg3;
39736   if (!argp3) {
39737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39738     return ;
39739   }
39740   arg3 = *argp3;
39741   argp4 = (Dali::AlphaFunction *)jarg4;
39742   if (!argp4) {
39743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39744     return ;
39745   }
39746   arg4 = *argp4;
39747   argp5 = (Dali::TimePeriod *)jarg5;
39748   if (!argp5) {
39749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39750     return ;
39751   }
39752   arg5 = *argp5;
39753   {
39754     try {
39755       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39756     } catch (std::out_of_range& e) {
39757       {
39758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39759       };
39760     } catch (std::exception& e) {
39761       {
39762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39763       };
39764     } catch (...) {
39765       {
39766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39767       };
39768     }
39769   }
39770 }
39771
39772
39773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39774   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39775   SwigValueWrapper< Dali::Property > arg2 ;
39776   Dali::KeyFrames *arg3 = 0 ;
39777   Dali::Property *argp2 ;
39778
39779   arg1 = (Dali::Animation *)jarg1;
39780   argp2 = (Dali::Property *)jarg2;
39781   if (!argp2) {
39782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39783     return ;
39784   }
39785   arg2 = *argp2;
39786   arg3 = (Dali::KeyFrames *)jarg3;
39787   if (!arg3) {
39788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39789     return ;
39790   }
39791   {
39792     try {
39793       (arg1)->AnimateBetween(arg2,*arg3);
39794     } catch (std::out_of_range& e) {
39795       {
39796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39797       };
39798     } catch (std::exception& e) {
39799       {
39800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39801       };
39802     } catch (...) {
39803       {
39804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39805       };
39806     }
39807   }
39808 }
39809
39810
39811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39812   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39813   SwigValueWrapper< Dali::Property > arg2 ;
39814   Dali::KeyFrames *arg3 = 0 ;
39815   Dali::Animation::Interpolation arg4 ;
39816   Dali::Property *argp2 ;
39817
39818   arg1 = (Dali::Animation *)jarg1;
39819   argp2 = (Dali::Property *)jarg2;
39820   if (!argp2) {
39821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39822     return ;
39823   }
39824   arg2 = *argp2;
39825   arg3 = (Dali::KeyFrames *)jarg3;
39826   if (!arg3) {
39827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39828     return ;
39829   }
39830   arg4 = (Dali::Animation::Interpolation)jarg4;
39831   {
39832     try {
39833       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39834     } catch (std::out_of_range& e) {
39835       {
39836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39837       };
39838     } catch (std::exception& e) {
39839       {
39840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39841       };
39842     } catch (...) {
39843       {
39844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39845       };
39846     }
39847   }
39848 }
39849
39850
39851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39852   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39853   SwigValueWrapper< Dali::Property > arg2 ;
39854   Dali::KeyFrames *arg3 = 0 ;
39855   Dali::AlphaFunction arg4 ;
39856   Dali::Property *argp2 ;
39857   Dali::AlphaFunction *argp4 ;
39858
39859   arg1 = (Dali::Animation *)jarg1;
39860   argp2 = (Dali::Property *)jarg2;
39861   if (!argp2) {
39862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39863     return ;
39864   }
39865   arg2 = *argp2;
39866   arg3 = (Dali::KeyFrames *)jarg3;
39867   if (!arg3) {
39868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39869     return ;
39870   }
39871   argp4 = (Dali::AlphaFunction *)jarg4;
39872   if (!argp4) {
39873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39874     return ;
39875   }
39876   arg4 = *argp4;
39877   {
39878     try {
39879       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39880     } catch (std::out_of_range& e) {
39881       {
39882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39883       };
39884     } catch (std::exception& e) {
39885       {
39886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39887       };
39888     } catch (...) {
39889       {
39890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39891       };
39892     }
39893   }
39894 }
39895
39896
39897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39898   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39899   SwigValueWrapper< Dali::Property > arg2 ;
39900   Dali::KeyFrames *arg3 = 0 ;
39901   Dali::AlphaFunction arg4 ;
39902   Dali::Animation::Interpolation arg5 ;
39903   Dali::Property *argp2 ;
39904   Dali::AlphaFunction *argp4 ;
39905
39906   arg1 = (Dali::Animation *)jarg1;
39907   argp2 = (Dali::Property *)jarg2;
39908   if (!argp2) {
39909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39910     return ;
39911   }
39912   arg2 = *argp2;
39913   arg3 = (Dali::KeyFrames *)jarg3;
39914   if (!arg3) {
39915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39916     return ;
39917   }
39918   argp4 = (Dali::AlphaFunction *)jarg4;
39919   if (!argp4) {
39920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39921     return ;
39922   }
39923   arg4 = *argp4;
39924   arg5 = (Dali::Animation::Interpolation)jarg5;
39925   {
39926     try {
39927       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39928     } catch (std::out_of_range& e) {
39929       {
39930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39931       };
39932     } catch (std::exception& e) {
39933       {
39934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39935       };
39936     } catch (...) {
39937       {
39938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39939       };
39940     }
39941   }
39942 }
39943
39944
39945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39946   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39947   SwigValueWrapper< Dali::Property > arg2 ;
39948   Dali::KeyFrames *arg3 = 0 ;
39949   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39950   Dali::Property *argp2 ;
39951   Dali::TimePeriod *argp4 ;
39952
39953   arg1 = (Dali::Animation *)jarg1;
39954   argp2 = (Dali::Property *)jarg2;
39955   if (!argp2) {
39956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39957     return ;
39958   }
39959   arg2 = *argp2;
39960   arg3 = (Dali::KeyFrames *)jarg3;
39961   if (!arg3) {
39962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39963     return ;
39964   }
39965   argp4 = (Dali::TimePeriod *)jarg4;
39966   if (!argp4) {
39967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39968     return ;
39969   }
39970   arg4 = *argp4;
39971   {
39972     try {
39973       (arg1)->AnimateBetween(arg2,*arg3,arg4);
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_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39992   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39993   SwigValueWrapper< Dali::Property > arg2 ;
39994   Dali::KeyFrames *arg3 = 0 ;
39995   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39996   Dali::Animation::Interpolation arg5 ;
39997   Dali::Property *argp2 ;
39998   Dali::TimePeriod *argp4 ;
39999
40000   arg1 = (Dali::Animation *)jarg1;
40001   argp2 = (Dali::Property *)jarg2;
40002   if (!argp2) {
40003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40004     return ;
40005   }
40006   arg2 = *argp2;
40007   arg3 = (Dali::KeyFrames *)jarg3;
40008   if (!arg3) {
40009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40010     return ;
40011   }
40012   argp4 = (Dali::TimePeriod *)jarg4;
40013   if (!argp4) {
40014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40015     return ;
40016   }
40017   arg4 = *argp4;
40018   arg5 = (Dali::Animation::Interpolation)jarg5;
40019   {
40020     try {
40021       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40022     } catch (std::out_of_range& e) {
40023       {
40024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40025       };
40026     } catch (std::exception& e) {
40027       {
40028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40029       };
40030     } catch (...) {
40031       {
40032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40033       };
40034     }
40035   }
40036 }
40037
40038
40039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40040   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40041   SwigValueWrapper< Dali::Property > arg2 ;
40042   Dali::KeyFrames *arg3 = 0 ;
40043   Dali::AlphaFunction arg4 ;
40044   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40045   Dali::Property *argp2 ;
40046   Dali::AlphaFunction *argp4 ;
40047   Dali::TimePeriod *argp5 ;
40048
40049   arg1 = (Dali::Animation *)jarg1;
40050   argp2 = (Dali::Property *)jarg2;
40051   if (!argp2) {
40052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40053     return ;
40054   }
40055   arg2 = *argp2;
40056   arg3 = (Dali::KeyFrames *)jarg3;
40057   if (!arg3) {
40058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40059     return ;
40060   }
40061   argp4 = (Dali::AlphaFunction *)jarg4;
40062   if (!argp4) {
40063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40064     return ;
40065   }
40066   arg4 = *argp4;
40067   argp5 = (Dali::TimePeriod *)jarg5;
40068   if (!argp5) {
40069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40070     return ;
40071   }
40072   arg5 = *argp5;
40073   {
40074     try {
40075       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40076     } catch (std::out_of_range& e) {
40077       {
40078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40079       };
40080     } catch (std::exception& e) {
40081       {
40082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40083       };
40084     } catch (...) {
40085       {
40086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40087       };
40088     }
40089   }
40090 }
40091
40092
40093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
40094   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40095   SwigValueWrapper< Dali::Property > arg2 ;
40096   Dali::KeyFrames *arg3 = 0 ;
40097   Dali::AlphaFunction arg4 ;
40098   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40099   Dali::Animation::Interpolation arg6 ;
40100   Dali::Property *argp2 ;
40101   Dali::AlphaFunction *argp4 ;
40102   Dali::TimePeriod *argp5 ;
40103
40104   arg1 = (Dali::Animation *)jarg1;
40105   argp2 = (Dali::Property *)jarg2;
40106   if (!argp2) {
40107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40108     return ;
40109   }
40110   arg2 = *argp2;
40111   arg3 = (Dali::KeyFrames *)jarg3;
40112   if (!arg3) {
40113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40114     return ;
40115   }
40116   argp4 = (Dali::AlphaFunction *)jarg4;
40117   if (!argp4) {
40118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40119     return ;
40120   }
40121   arg4 = *argp4;
40122   argp5 = (Dali::TimePeriod *)jarg5;
40123   if (!argp5) {
40124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40125     return ;
40126   }
40127   arg5 = *argp5;
40128   arg6 = (Dali::Animation::Interpolation)jarg6;
40129   {
40130     try {
40131       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
40132     } catch (std::out_of_range& e) {
40133       {
40134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40135       };
40136     } catch (std::exception& e) {
40137       {
40138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40139       };
40140     } catch (...) {
40141       {
40142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40143       };
40144     }
40145   }
40146 }
40147
40148
40149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40150   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40151   Dali::Actor arg2 ;
40152   Dali::Path arg3 ;
40153   Dali::Vector3 *arg4 = 0 ;
40154   Dali::Actor *argp2 ;
40155   Dali::Path *argp3 ;
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   {
40176     try {
40177       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
40178     } catch (std::out_of_range& e) {
40179       {
40180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40181       };
40182     } catch (std::exception& e) {
40183       {
40184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40185       };
40186     } catch (...) {
40187       {
40188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40189       };
40190     }
40191   }
40192 }
40193
40194
40195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40196   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40197   Dali::Actor arg2 ;
40198   Dali::Path arg3 ;
40199   Dali::Vector3 *arg4 = 0 ;
40200   Dali::AlphaFunction arg5 ;
40201   Dali::Actor *argp2 ;
40202   Dali::Path *argp3 ;
40203   Dali::AlphaFunction *argp5 ;
40204
40205   arg1 = (Dali::Animation *)jarg1;
40206   argp2 = (Dali::Actor *)jarg2;
40207   if (!argp2) {
40208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40209     return ;
40210   }
40211   arg2 = *argp2;
40212   argp3 = (Dali::Path *)jarg3;
40213   if (!argp3) {
40214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40215     return ;
40216   }
40217   arg3 = *argp3;
40218   arg4 = (Dali::Vector3 *)jarg4;
40219   if (!arg4) {
40220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40221     return ;
40222   }
40223   argp5 = (Dali::AlphaFunction *)jarg5;
40224   if (!argp5) {
40225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40226     return ;
40227   }
40228   arg5 = *argp5;
40229   {
40230     try {
40231       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40232     } catch (std::out_of_range& e) {
40233       {
40234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40235       };
40236     } catch (std::exception& e) {
40237       {
40238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40239       };
40240     } catch (...) {
40241       {
40242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40243       };
40244     }
40245   }
40246 }
40247
40248
40249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40250   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40251   Dali::Actor arg2 ;
40252   Dali::Path arg3 ;
40253   Dali::Vector3 *arg4 = 0 ;
40254   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40255   Dali::Actor *argp2 ;
40256   Dali::Path *argp3 ;
40257   Dali::TimePeriod *argp5 ;
40258
40259   arg1 = (Dali::Animation *)jarg1;
40260   argp2 = (Dali::Actor *)jarg2;
40261   if (!argp2) {
40262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40263     return ;
40264   }
40265   arg2 = *argp2;
40266   argp3 = (Dali::Path *)jarg3;
40267   if (!argp3) {
40268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40269     return ;
40270   }
40271   arg3 = *argp3;
40272   arg4 = (Dali::Vector3 *)jarg4;
40273   if (!arg4) {
40274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40275     return ;
40276   }
40277   argp5 = (Dali::TimePeriod *)jarg5;
40278   if (!argp5) {
40279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40280     return ;
40281   }
40282   arg5 = *argp5;
40283   {
40284     try {
40285       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40286     } catch (std::out_of_range& e) {
40287       {
40288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40289       };
40290     } catch (std::exception& e) {
40291       {
40292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40293       };
40294     } catch (...) {
40295       {
40296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40297       };
40298     }
40299   }
40300 }
40301
40302
40303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
40304   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40305   Dali::Actor arg2 ;
40306   Dali::Path arg3 ;
40307   Dali::Vector3 *arg4 = 0 ;
40308   Dali::AlphaFunction arg5 ;
40309   SwigValueWrapper< Dali::TimePeriod > arg6 ;
40310   Dali::Actor *argp2 ;
40311   Dali::Path *argp3 ;
40312   Dali::AlphaFunction *argp5 ;
40313   Dali::TimePeriod *argp6 ;
40314
40315   arg1 = (Dali::Animation *)jarg1;
40316   argp2 = (Dali::Actor *)jarg2;
40317   if (!argp2) {
40318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40319     return ;
40320   }
40321   arg2 = *argp2;
40322   argp3 = (Dali::Path *)jarg3;
40323   if (!argp3) {
40324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40325     return ;
40326   }
40327   arg3 = *argp3;
40328   arg4 = (Dali::Vector3 *)jarg4;
40329   if (!arg4) {
40330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40331     return ;
40332   }
40333   argp5 = (Dali::AlphaFunction *)jarg5;
40334   if (!argp5) {
40335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40336     return ;
40337   }
40338   arg5 = *argp5;
40339   argp6 = (Dali::TimePeriod *)jarg6;
40340   if (!argp6) {
40341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40342     return ;
40343   }
40344   arg6 = *argp6;
40345   {
40346     try {
40347       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
40348     } catch (std::out_of_range& e) {
40349       {
40350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40351       };
40352     } catch (std::exception& e) {
40353       {
40354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40355       };
40356     } catch (...) {
40357       {
40358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40359       };
40360     }
40361   }
40362 }
40363
40364
40365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
40366   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40367   Dali::Actor arg2 ;
40368   float arg3 ;
40369   Dali::Actor *argp2 ;
40370
40371   arg1 = (Dali::Animation *)jarg1;
40372   argp2 = (Dali::Actor *)jarg2;
40373   if (!argp2) {
40374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40375     return ;
40376   }
40377   arg2 = *argp2;
40378   arg3 = (float)jarg3;
40379   {
40380     try {
40381       (arg1)->Show(arg2,arg3);
40382     } catch (std::out_of_range& e) {
40383       {
40384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40385       };
40386     } catch (std::exception& e) {
40387       {
40388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40389       };
40390     } catch (...) {
40391       {
40392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40393       };
40394     }
40395   }
40396 }
40397
40398
40399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
40400   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40401   Dali::Actor arg2 ;
40402   float arg3 ;
40403   Dali::Actor *argp2 ;
40404
40405   arg1 = (Dali::Animation *)jarg1;
40406   argp2 = (Dali::Actor *)jarg2;
40407   if (!argp2) {
40408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40409     return ;
40410   }
40411   arg2 = *argp2;
40412   arg3 = (float)jarg3;
40413   {
40414     try {
40415       (arg1)->Hide(arg2,arg3);
40416     } catch (std::out_of_range& e) {
40417       {
40418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40419       };
40420     } catch (std::exception& e) {
40421       {
40422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40423       };
40424     } catch (...) {
40425       {
40426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40427       };
40428     }
40429   }
40430 }
40431
40432
40433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
40434   int jresult ;
40435   int result;
40436
40437   result = (int)Dali::LinearConstrainer::Property::VALUE;
40438   jresult = (int)result;
40439   return jresult;
40440 }
40441
40442
40443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
40444   int jresult ;
40445   int result;
40446
40447   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
40448   jresult = (int)result;
40449   return jresult;
40450 }
40451
40452
40453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
40454   void * jresult ;
40455   Dali::LinearConstrainer::Property *result = 0 ;
40456
40457   {
40458     try {
40459       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
40460     } catch (std::out_of_range& e) {
40461       {
40462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40463       };
40464     } catch (std::exception& e) {
40465       {
40466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40467       };
40468     } catch (...) {
40469       {
40470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40471       };
40472     }
40473   }
40474   jresult = (void *)result;
40475   return jresult;
40476 }
40477
40478
40479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
40480   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40481
40482   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40483   {
40484     try {
40485       delete arg1;
40486     } catch (std::out_of_range& e) {
40487       {
40488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40489       };
40490     } catch (std::exception& e) {
40491       {
40492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40493       };
40494     } catch (...) {
40495       {
40496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40497       };
40498     }
40499   }
40500 }
40501
40502
40503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
40504   void * jresult ;
40505   Dali::LinearConstrainer result;
40506
40507   {
40508     try {
40509       result = Dali::LinearConstrainer::New();
40510     } catch (std::out_of_range& e) {
40511       {
40512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40513       };
40514     } catch (std::exception& e) {
40515       {
40516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40517       };
40518     } catch (...) {
40519       {
40520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40521       };
40522     }
40523   }
40524   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40525   return jresult;
40526 }
40527
40528
40529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
40530   void * jresult ;
40531   Dali::BaseHandle arg1 ;
40532   Dali::BaseHandle *argp1 ;
40533   Dali::LinearConstrainer result;
40534
40535   argp1 = (Dali::BaseHandle *)jarg1;
40536   if (!argp1) {
40537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40538     return 0;
40539   }
40540   arg1 = *argp1;
40541   {
40542     try {
40543       result = Dali::LinearConstrainer::DownCast(arg1);
40544     } catch (std::out_of_range& e) {
40545       {
40546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40547       };
40548     } catch (std::exception& e) {
40549       {
40550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40551       };
40552     } catch (...) {
40553       {
40554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40555       };
40556     }
40557   }
40558   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40559   return jresult;
40560 }
40561
40562
40563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
40564   void * jresult ;
40565   Dali::LinearConstrainer *result = 0 ;
40566
40567   {
40568     try {
40569       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40570     } catch (std::out_of_range& e) {
40571       {
40572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40573       };
40574     } catch (std::exception& e) {
40575       {
40576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40577       };
40578     } catch (...) {
40579       {
40580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40581       };
40582     }
40583   }
40584   jresult = (void *)result;
40585   return jresult;
40586 }
40587
40588
40589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
40590   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40591
40592   arg1 = (Dali::LinearConstrainer *)jarg1;
40593   {
40594     try {
40595       delete arg1;
40596     } catch (std::out_of_range& e) {
40597       {
40598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40599       };
40600     } catch (std::exception& e) {
40601       {
40602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40603       };
40604     } catch (...) {
40605       {
40606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40607       };
40608     }
40609   }
40610 }
40611
40612
40613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
40614   void * jresult ;
40615   Dali::LinearConstrainer *arg1 = 0 ;
40616   Dali::LinearConstrainer *result = 0 ;
40617
40618   arg1 = (Dali::LinearConstrainer *)jarg1;
40619   if (!arg1) {
40620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40621     return 0;
40622   }
40623   {
40624     try {
40625       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40626     } catch (std::out_of_range& e) {
40627       {
40628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40629       };
40630     } catch (std::exception& e) {
40631       {
40632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40633       };
40634     } catch (...) {
40635       {
40636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40637       };
40638     }
40639   }
40640   jresult = (void *)result;
40641   return jresult;
40642 }
40643
40644
40645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40646   void * jresult ;
40647   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40648   Dali::LinearConstrainer *arg2 = 0 ;
40649   Dali::LinearConstrainer *result = 0 ;
40650
40651   arg1 = (Dali::LinearConstrainer *)jarg1;
40652   arg2 = (Dali::LinearConstrainer *)jarg2;
40653   if (!arg2) {
40654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40655     return 0;
40656   }
40657   {
40658     try {
40659       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40660     } catch (std::out_of_range& e) {
40661       {
40662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40663       };
40664     } catch (std::exception& e) {
40665       {
40666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40667       };
40668     } catch (...) {
40669       {
40670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40671       };
40672     }
40673   }
40674   jresult = (void *)result;
40675   return jresult;
40676 }
40677
40678
40679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40680   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40681   SwigValueWrapper< Dali::Property > arg2 ;
40682   SwigValueWrapper< Dali::Property > arg3 ;
40683   Dali::Vector2 *arg4 = 0 ;
40684   Dali::Vector2 *arg5 = 0 ;
40685   Dali::Property *argp2 ;
40686   Dali::Property *argp3 ;
40687
40688   arg1 = (Dali::LinearConstrainer *)jarg1;
40689   argp2 = (Dali::Property *)jarg2;
40690   if (!argp2) {
40691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40692     return ;
40693   }
40694   arg2 = *argp2;
40695   argp3 = (Dali::Property *)jarg3;
40696   if (!argp3) {
40697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40698     return ;
40699   }
40700   arg3 = *argp3;
40701   arg4 = (Dali::Vector2 *)jarg4;
40702   if (!arg4) {
40703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40704     return ;
40705   }
40706   arg5 = (Dali::Vector2 *)jarg5;
40707   if (!arg5) {
40708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40709     return ;
40710   }
40711   {
40712     try {
40713       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40714     } catch (std::out_of_range& e) {
40715       {
40716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40717       };
40718     } catch (std::exception& e) {
40719       {
40720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40721       };
40722     } catch (...) {
40723       {
40724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40725       };
40726     }
40727   }
40728 }
40729
40730
40731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40732   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40733   SwigValueWrapper< Dali::Property > arg2 ;
40734   SwigValueWrapper< Dali::Property > arg3 ;
40735   Dali::Vector2 *arg4 = 0 ;
40736   Dali::Property *argp2 ;
40737   Dali::Property *argp3 ;
40738
40739   arg1 = (Dali::LinearConstrainer *)jarg1;
40740   argp2 = (Dali::Property *)jarg2;
40741   if (!argp2) {
40742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40743     return ;
40744   }
40745   arg2 = *argp2;
40746   argp3 = (Dali::Property *)jarg3;
40747   if (!argp3) {
40748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40749     return ;
40750   }
40751   arg3 = *argp3;
40752   arg4 = (Dali::Vector2 *)jarg4;
40753   if (!arg4) {
40754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40755     return ;
40756   }
40757   {
40758     try {
40759       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40760     } catch (std::out_of_range& e) {
40761       {
40762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40763       };
40764     } catch (std::exception& e) {
40765       {
40766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40767       };
40768     } catch (...) {
40769       {
40770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40771       };
40772     }
40773   }
40774 }
40775
40776
40777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40778   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40779   Dali::Handle *arg2 = 0 ;
40780
40781   arg1 = (Dali::LinearConstrainer *)jarg1;
40782   arg2 = (Dali::Handle *)jarg2;
40783   if (!arg2) {
40784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40785     return ;
40786   }
40787   {
40788     try {
40789       (arg1)->Remove(*arg2);
40790     } catch (std::out_of_range& e) {
40791       {
40792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40793       };
40794     } catch (std::exception& e) {
40795       {
40796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40797       };
40798     } catch (...) {
40799       {
40800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40801       };
40802     }
40803   }
40804 }
40805
40806
40807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
40808   int jresult ;
40809   int result;
40810
40811   result = (int)Dali::PathConstrainer::Property::FORWARD;
40812   jresult = (int)result;
40813   return jresult;
40814 }
40815
40816
40817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
40818   int jresult ;
40819   int result;
40820
40821   result = (int)Dali::PathConstrainer::Property::POINTS;
40822   jresult = (int)result;
40823   return jresult;
40824 }
40825
40826
40827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
40828   int jresult ;
40829   int result;
40830
40831   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40832   jresult = (int)result;
40833   return jresult;
40834 }
40835
40836
40837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
40838   void * jresult ;
40839   Dali::PathConstrainer::Property *result = 0 ;
40840
40841   {
40842     try {
40843       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40844     } catch (std::out_of_range& e) {
40845       {
40846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40847       };
40848     } catch (std::exception& e) {
40849       {
40850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40851       };
40852     } catch (...) {
40853       {
40854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40855       };
40856     }
40857   }
40858   jresult = (void *)result;
40859   return jresult;
40860 }
40861
40862
40863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
40864   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40865
40866   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40867   {
40868     try {
40869       delete arg1;
40870     } catch (std::out_of_range& e) {
40871       {
40872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40873       };
40874     } catch (std::exception& e) {
40875       {
40876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40877       };
40878     } catch (...) {
40879       {
40880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40881       };
40882     }
40883   }
40884 }
40885
40886
40887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
40888   void * jresult ;
40889   Dali::PathConstrainer result;
40890
40891   {
40892     try {
40893       result = Dali::PathConstrainer::New();
40894     } catch (std::out_of_range& e) {
40895       {
40896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40897       };
40898     } catch (std::exception& e) {
40899       {
40900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40901       };
40902     } catch (...) {
40903       {
40904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40905       };
40906     }
40907   }
40908   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40909   return jresult;
40910 }
40911
40912
40913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
40914   void * jresult ;
40915   Dali::BaseHandle arg1 ;
40916   Dali::BaseHandle *argp1 ;
40917   Dali::PathConstrainer result;
40918
40919   argp1 = (Dali::BaseHandle *)jarg1;
40920   if (!argp1) {
40921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40922     return 0;
40923   }
40924   arg1 = *argp1;
40925   {
40926     try {
40927       result = Dali::PathConstrainer::DownCast(arg1);
40928     } catch (std::out_of_range& e) {
40929       {
40930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40931       };
40932     } catch (std::exception& e) {
40933       {
40934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40935       };
40936     } catch (...) {
40937       {
40938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40939       };
40940     }
40941   }
40942   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40943   return jresult;
40944 }
40945
40946
40947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
40948   void * jresult ;
40949   Dali::PathConstrainer *result = 0 ;
40950
40951   {
40952     try {
40953       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
40954     } catch (std::out_of_range& e) {
40955       {
40956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40957       };
40958     } catch (std::exception& e) {
40959       {
40960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40961       };
40962     } catch (...) {
40963       {
40964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40965       };
40966     }
40967   }
40968   jresult = (void *)result;
40969   return jresult;
40970 }
40971
40972
40973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
40974   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40975
40976   arg1 = (Dali::PathConstrainer *)jarg1;
40977   {
40978     try {
40979       delete arg1;
40980     } catch (std::out_of_range& e) {
40981       {
40982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40983       };
40984     } catch (std::exception& e) {
40985       {
40986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40987       };
40988     } catch (...) {
40989       {
40990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40991       };
40992     }
40993   }
40994 }
40995
40996
40997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
40998   void * jresult ;
40999   Dali::PathConstrainer *arg1 = 0 ;
41000   Dali::PathConstrainer *result = 0 ;
41001
41002   arg1 = (Dali::PathConstrainer *)jarg1;
41003   if (!arg1) {
41004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41005     return 0;
41006   }
41007   {
41008     try {
41009       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
41010     } catch (std::out_of_range& e) {
41011       {
41012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41013       };
41014     } catch (std::exception& e) {
41015       {
41016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41017       };
41018     } catch (...) {
41019       {
41020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41021       };
41022     }
41023   }
41024   jresult = (void *)result;
41025   return jresult;
41026 }
41027
41028
41029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
41030   void * jresult ;
41031   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41032   Dali::PathConstrainer *arg2 = 0 ;
41033   Dali::PathConstrainer *result = 0 ;
41034
41035   arg1 = (Dali::PathConstrainer *)jarg1;
41036   arg2 = (Dali::PathConstrainer *)jarg2;
41037   if (!arg2) {
41038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41039     return 0;
41040   }
41041   {
41042     try {
41043       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
41044     } catch (std::out_of_range& e) {
41045       {
41046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41047       };
41048     } catch (std::exception& e) {
41049       {
41050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41051       };
41052     } catch (...) {
41053       {
41054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41055       };
41056     }
41057   }
41058   jresult = (void *)result;
41059   return jresult;
41060 }
41061
41062
41063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
41064   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41065   SwigValueWrapper< Dali::Property > arg2 ;
41066   SwigValueWrapper< Dali::Property > arg3 ;
41067   Dali::Vector2 *arg4 = 0 ;
41068   Dali::Vector2 *arg5 = 0 ;
41069   Dali::Property *argp2 ;
41070   Dali::Property *argp3 ;
41071
41072   arg1 = (Dali::PathConstrainer *)jarg1;
41073   argp2 = (Dali::Property *)jarg2;
41074   if (!argp2) {
41075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41076     return ;
41077   }
41078   arg2 = *argp2;
41079   argp3 = (Dali::Property *)jarg3;
41080   if (!argp3) {
41081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41082     return ;
41083   }
41084   arg3 = *argp3;
41085   arg4 = (Dali::Vector2 *)jarg4;
41086   if (!arg4) {
41087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41088     return ;
41089   }
41090   arg5 = (Dali::Vector2 *)jarg5;
41091   if (!arg5) {
41092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41093     return ;
41094   }
41095   {
41096     try {
41097       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
41098     } catch (std::out_of_range& e) {
41099       {
41100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41101       };
41102     } catch (std::exception& e) {
41103       {
41104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41105       };
41106     } catch (...) {
41107       {
41108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41109       };
41110     }
41111   }
41112 }
41113
41114
41115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
41116   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41117   SwigValueWrapper< Dali::Property > arg2 ;
41118   SwigValueWrapper< Dali::Property > arg3 ;
41119   Dali::Vector2 *arg4 = 0 ;
41120   Dali::Property *argp2 ;
41121   Dali::Property *argp3 ;
41122
41123   arg1 = (Dali::PathConstrainer *)jarg1;
41124   argp2 = (Dali::Property *)jarg2;
41125   if (!argp2) {
41126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41127     return ;
41128   }
41129   arg2 = *argp2;
41130   argp3 = (Dali::Property *)jarg3;
41131   if (!argp3) {
41132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41133     return ;
41134   }
41135   arg3 = *argp3;
41136   arg4 = (Dali::Vector2 *)jarg4;
41137   if (!arg4) {
41138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41139     return ;
41140   }
41141   {
41142     try {
41143       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
41144     } catch (std::out_of_range& e) {
41145       {
41146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41147       };
41148     } catch (std::exception& e) {
41149       {
41150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41151       };
41152     } catch (...) {
41153       {
41154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41155       };
41156     }
41157   }
41158 }
41159
41160
41161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
41162   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41163   Dali::Handle *arg2 = 0 ;
41164
41165   arg1 = (Dali::PathConstrainer *)jarg1;
41166   arg2 = (Dali::Handle *)jarg2;
41167   if (!arg2) {
41168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
41169     return ;
41170   }
41171   {
41172     try {
41173       (arg1)->Remove(*arg2);
41174     } catch (std::out_of_range& e) {
41175       {
41176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41177       };
41178     } catch (std::exception& e) {
41179       {
41180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41181       };
41182     } catch (...) {
41183       {
41184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41185       };
41186     }
41187   }
41188 }
41189
41190
41191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
41192   int jresult ;
41193   Dali::FittingMode::Type result;
41194
41195   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
41196   jresult = (int)result;
41197   return jresult;
41198 }
41199
41200
41201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
41202   int jresult ;
41203   Dali::SamplingMode::Type result;
41204
41205   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
41206   jresult = (int)result;
41207   return jresult;
41208 }
41209
41210
41211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
41212   void * jresult ;
41213   Dali::BufferImage *result = 0 ;
41214
41215   {
41216     try {
41217       result = (Dali::BufferImage *)new Dali::BufferImage();
41218     } catch (std::out_of_range& e) {
41219       {
41220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41221       };
41222     } catch (std::exception& e) {
41223       {
41224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41225       };
41226     } catch (...) {
41227       {
41228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41229       };
41230     }
41231   }
41232   jresult = (void *)result;
41233   return jresult;
41234 }
41235
41236
41237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41238   void * jresult ;
41239   unsigned int arg1 ;
41240   unsigned int arg2 ;
41241   Dali::Pixel::Format arg3 ;
41242   Dali::BufferImage result;
41243
41244   arg1 = (unsigned int)jarg1;
41245   arg2 = (unsigned int)jarg2;
41246   arg3 = (Dali::Pixel::Format)jarg3;
41247   {
41248     try {
41249       result = Dali::BufferImage::New(arg1,arg2,arg3);
41250     } catch (std::out_of_range& e) {
41251       {
41252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41253       };
41254     } catch (std::exception& e) {
41255       {
41256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41257       };
41258     } catch (...) {
41259       {
41260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41261       };
41262     }
41263   }
41264   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41265   return jresult;
41266 }
41267
41268
41269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
41270   void * jresult ;
41271   unsigned int arg1 ;
41272   unsigned int arg2 ;
41273   Dali::BufferImage result;
41274
41275   arg1 = (unsigned int)jarg1;
41276   arg2 = (unsigned int)jarg2;
41277   {
41278     try {
41279       result = Dali::BufferImage::New(arg1,arg2);
41280     } catch (std::out_of_range& e) {
41281       {
41282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41283       };
41284     } catch (std::exception& e) {
41285       {
41286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41287       };
41288     } catch (...) {
41289       {
41290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41291       };
41292     }
41293   }
41294   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41295   return jresult;
41296 }
41297
41298
41299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
41300   void * jresult ;
41301   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41302   unsigned int arg2 ;
41303   unsigned int arg3 ;
41304   Dali::Pixel::Format arg4 ;
41305   unsigned int arg5 ;
41306   Dali::BufferImage result;
41307
41308   arg1 = jarg1;
41309   arg2 = (unsigned int)jarg2;
41310   arg3 = (unsigned int)jarg3;
41311   arg4 = (Dali::Pixel::Format)jarg4;
41312   arg5 = (unsigned int)jarg5;
41313   {
41314     try {
41315       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
41316     } catch (std::out_of_range& e) {
41317       {
41318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41319       };
41320     } catch (std::exception& e) {
41321       {
41322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41323       };
41324     } catch (...) {
41325       {
41326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41327       };
41328     }
41329   }
41330   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41331
41332
41333   return jresult;
41334 }
41335
41336
41337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
41338   void * jresult ;
41339   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41340   unsigned int arg2 ;
41341   unsigned int arg3 ;
41342   Dali::Pixel::Format arg4 ;
41343   Dali::BufferImage result;
41344
41345   arg1 = jarg1;
41346   arg2 = (unsigned int)jarg2;
41347   arg3 = (unsigned int)jarg3;
41348   arg4 = (Dali::Pixel::Format)jarg4;
41349   {
41350     try {
41351       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
41352     } catch (std::out_of_range& e) {
41353       {
41354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41355       };
41356     } catch (std::exception& e) {
41357       {
41358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41359       };
41360     } catch (...) {
41361       {
41362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41363       };
41364     }
41365   }
41366   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41367
41368
41369   return jresult;
41370 }
41371
41372
41373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
41374   void * jresult ;
41375   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41376   unsigned int arg2 ;
41377   unsigned int arg3 ;
41378   Dali::BufferImage result;
41379
41380   arg1 = jarg1;
41381   arg2 = (unsigned int)jarg2;
41382   arg3 = (unsigned int)jarg3;
41383   {
41384     try {
41385       result = Dali::BufferImage::New(arg1,arg2,arg3);
41386     } catch (std::out_of_range& e) {
41387       {
41388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41389       };
41390     } catch (std::exception& e) {
41391       {
41392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41393       };
41394     } catch (...) {
41395       {
41396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41397       };
41398     }
41399   }
41400   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41401
41402
41403   return jresult;
41404 }
41405
41406
41407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
41408   void * jresult ;
41409   Dali::BaseHandle arg1 ;
41410   Dali::BaseHandle *argp1 ;
41411   Dali::BufferImage result;
41412
41413   argp1 = (Dali::BaseHandle *)jarg1;
41414   if (!argp1) {
41415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41416     return 0;
41417   }
41418   arg1 = *argp1;
41419   {
41420     try {
41421       result = Dali::BufferImage::DownCast(arg1);
41422     } catch (std::out_of_range& e) {
41423       {
41424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41425       };
41426     } catch (std::exception& e) {
41427       {
41428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41429       };
41430     } catch (...) {
41431       {
41432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41433       };
41434     }
41435   }
41436   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41437   return jresult;
41438 }
41439
41440
41441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
41442   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41443
41444   arg1 = (Dali::BufferImage *)jarg1;
41445   {
41446     try {
41447       delete arg1;
41448     } catch (std::out_of_range& e) {
41449       {
41450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41451       };
41452     } catch (std::exception& e) {
41453       {
41454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41455       };
41456     } catch (...) {
41457       {
41458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41459       };
41460     }
41461   }
41462 }
41463
41464
41465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
41466   void * jresult ;
41467   Dali::BufferImage *arg1 = 0 ;
41468   Dali::BufferImage *result = 0 ;
41469
41470   arg1 = (Dali::BufferImage *)jarg1;
41471   if (!arg1) {
41472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41473     return 0;
41474   }
41475   {
41476     try {
41477       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
41478     } catch (std::out_of_range& e) {
41479       {
41480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41481       };
41482     } catch (std::exception& e) {
41483       {
41484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41485       };
41486     } catch (...) {
41487       {
41488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41489       };
41490     }
41491   }
41492   jresult = (void *)result;
41493   return jresult;
41494 }
41495
41496
41497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
41498   void * jresult ;
41499   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41500   Dali::BufferImage *arg2 = 0 ;
41501   Dali::BufferImage *result = 0 ;
41502
41503   arg1 = (Dali::BufferImage *)jarg1;
41504   arg2 = (Dali::BufferImage *)jarg2;
41505   if (!arg2) {
41506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41507     return 0;
41508   }
41509   {
41510     try {
41511       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41512     } catch (std::out_of_range& e) {
41513       {
41514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41515       };
41516     } catch (std::exception& e) {
41517       {
41518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41519       };
41520     } catch (...) {
41521       {
41522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41523       };
41524     }
41525   }
41526   jresult = (void *)result;
41527   return jresult;
41528 }
41529
41530
41531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
41532   void * jresult ;
41533   Dali::BufferImage result;
41534
41535   {
41536     try {
41537       result = Dali::BufferImage::WHITE();
41538     } catch (std::out_of_range& e) {
41539       {
41540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41541       };
41542     } catch (std::exception& e) {
41543       {
41544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41545       };
41546     } catch (...) {
41547       {
41548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41549       };
41550     }
41551   }
41552   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41553   return jresult;
41554 }
41555
41556
41557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
41558   void * jresult ;
41559   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41560   Dali::PixelBuffer *result = 0 ;
41561
41562   arg1 = (Dali::BufferImage *)jarg1;
41563   {
41564     try {
41565       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41566     } catch (std::out_of_range& e) {
41567       {
41568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41569       };
41570     } catch (std::exception& e) {
41571       {
41572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41573       };
41574     } catch (...) {
41575       {
41576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41577       };
41578     }
41579   }
41580   jresult = (void *)result;
41581   return jresult;
41582 }
41583
41584
41585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
41586   unsigned int jresult ;
41587   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41588   unsigned int result;
41589
41590   arg1 = (Dali::BufferImage *)jarg1;
41591   {
41592     try {
41593       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
41594     } catch (std::out_of_range& e) {
41595       {
41596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41597       };
41598     } catch (std::exception& e) {
41599       {
41600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41601       };
41602     } catch (...) {
41603       {
41604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41605       };
41606     }
41607   }
41608   jresult = result;
41609   return jresult;
41610 }
41611
41612
41613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
41614   unsigned int jresult ;
41615   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41616   unsigned int result;
41617
41618   arg1 = (Dali::BufferImage *)jarg1;
41619   {
41620     try {
41621       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41622     } catch (std::out_of_range& e) {
41623       {
41624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41625       };
41626     } catch (std::exception& e) {
41627       {
41628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41629       };
41630     } catch (...) {
41631       {
41632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41633       };
41634     }
41635   }
41636   jresult = result;
41637   return jresult;
41638 }
41639
41640
41641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
41642   int jresult ;
41643   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41644   Dali::Pixel::Format result;
41645
41646   arg1 = (Dali::BufferImage *)jarg1;
41647   {
41648     try {
41649       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41650     } catch (std::out_of_range& e) {
41651       {
41652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41653       };
41654     } catch (std::exception& e) {
41655       {
41656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41657       };
41658     } catch (...) {
41659       {
41660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41661       };
41662     }
41663   }
41664   jresult = (int)result;
41665   return jresult;
41666 }
41667
41668
41669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
41670   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41671
41672   arg1 = (Dali::BufferImage *)jarg1;
41673   {
41674     try {
41675       (arg1)->Update();
41676     } catch (std::out_of_range& e) {
41677       {
41678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41679       };
41680     } catch (std::exception& e) {
41681       {
41682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41683       };
41684     } catch (...) {
41685       {
41686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41687       };
41688     }
41689   }
41690 }
41691
41692
41693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41694   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41695   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
41696   Dali::RectArea *argp2 ;
41697
41698   arg1 = (Dali::BufferImage *)jarg1;
41699   argp2 = (Dali::RectArea *)jarg2;
41700   if (!argp2) {
41701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41702     return ;
41703   }
41704   arg2 = *argp2;
41705   {
41706     try {
41707       (arg1)->Update(arg2);
41708     } catch (std::out_of_range& e) {
41709       {
41710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41711       };
41712     } catch (std::exception& e) {
41713       {
41714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41715       };
41716     } catch (...) {
41717       {
41718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41719       };
41720     }
41721   }
41722 }
41723
41724
41725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
41726   unsigned int jresult ;
41727   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41728   bool result;
41729
41730   arg1 = (Dali::BufferImage *)jarg1;
41731   {
41732     try {
41733       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
41734     } catch (std::out_of_range& e) {
41735       {
41736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41737       };
41738     } catch (std::exception& e) {
41739       {
41740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41741       };
41742     } catch (...) {
41743       {
41744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41745       };
41746     }
41747   }
41748   jresult = result;
41749   return jresult;
41750 }
41751
41752
41753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
41754   void * jresult ;
41755   Dali::EncodedBufferImage *result = 0 ;
41756
41757   {
41758     try {
41759       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41760     } catch (std::out_of_range& e) {
41761       {
41762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41763       };
41764     } catch (std::exception& e) {
41765       {
41766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41767       };
41768     } catch (...) {
41769       {
41770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41771       };
41772     }
41773   }
41774   jresult = (void *)result;
41775   return jresult;
41776 }
41777
41778
41779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41780   void * jresult ;
41781   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41782   std::size_t arg2 ;
41783   Dali::EncodedBufferImage result;
41784
41785   arg1 = (uint8_t *)jarg1;
41786   arg2 = (std::size_t)jarg2;
41787   {
41788     try {
41789       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
41790     } catch (std::out_of_range& e) {
41791       {
41792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41793       };
41794     } catch (std::exception& e) {
41795       {
41796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41797       };
41798     } catch (...) {
41799       {
41800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41801       };
41802     }
41803   }
41804   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41805   return jresult;
41806 }
41807
41808
41809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41810   void * jresult ;
41811   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41812   std::size_t arg2 ;
41813   Dali::ImageDimensions arg3 ;
41814   Dali::FittingMode::Type arg4 ;
41815   Dali::SamplingMode::Type arg5 ;
41816   bool arg6 ;
41817   Dali::ImageDimensions *argp3 ;
41818   Dali::EncodedBufferImage result;
41819
41820   arg1 = (uint8_t *)jarg1;
41821   arg2 = (std::size_t)jarg2;
41822   argp3 = (Dali::ImageDimensions *)jarg3;
41823   if (!argp3) {
41824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41825     return 0;
41826   }
41827   arg3 = *argp3;
41828   arg4 = (Dali::FittingMode::Type)jarg4;
41829   arg5 = (Dali::SamplingMode::Type)jarg5;
41830   arg6 = jarg6 ? true : false;
41831   {
41832     try {
41833       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41834     } catch (std::out_of_range& e) {
41835       {
41836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41837       };
41838     } catch (std::exception& e) {
41839       {
41840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41841       };
41842     } catch (...) {
41843       {
41844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41845       };
41846     }
41847   }
41848   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41849   return jresult;
41850 }
41851
41852
41853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41854   void * jresult ;
41855   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41856   std::size_t arg2 ;
41857   Dali::ImageDimensions arg3 ;
41858   Dali::FittingMode::Type arg4 ;
41859   Dali::SamplingMode::Type arg5 ;
41860   Dali::ImageDimensions *argp3 ;
41861   Dali::EncodedBufferImage result;
41862
41863   arg1 = (uint8_t *)jarg1;
41864   arg2 = (std::size_t)jarg2;
41865   argp3 = (Dali::ImageDimensions *)jarg3;
41866   if (!argp3) {
41867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41868     return 0;
41869   }
41870   arg3 = *argp3;
41871   arg4 = (Dali::FittingMode::Type)jarg4;
41872   arg5 = (Dali::SamplingMode::Type)jarg5;
41873   {
41874     try {
41875       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41876     } catch (std::out_of_range& e) {
41877       {
41878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41879       };
41880     } catch (std::exception& e) {
41881       {
41882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41883       };
41884     } catch (...) {
41885       {
41886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41887       };
41888     }
41889   }
41890   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41891   return jresult;
41892 }
41893
41894
41895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
41896   void * jresult ;
41897   Dali::BaseHandle arg1 ;
41898   Dali::BaseHandle *argp1 ;
41899   Dali::EncodedBufferImage result;
41900
41901   argp1 = (Dali::BaseHandle *)jarg1;
41902   if (!argp1) {
41903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41904     return 0;
41905   }
41906   arg1 = *argp1;
41907   {
41908     try {
41909       result = Dali::EncodedBufferImage::DownCast(arg1);
41910     } catch (std::out_of_range& e) {
41911       {
41912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41913       };
41914     } catch (std::exception& e) {
41915       {
41916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41917       };
41918     } catch (...) {
41919       {
41920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41921       };
41922     }
41923   }
41924   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41925   return jresult;
41926 }
41927
41928
41929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
41930   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41931
41932   arg1 = (Dali::EncodedBufferImage *)jarg1;
41933   {
41934     try {
41935       delete arg1;
41936     } catch (std::out_of_range& e) {
41937       {
41938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41939       };
41940     } catch (std::exception& e) {
41941       {
41942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41943       };
41944     } catch (...) {
41945       {
41946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41947       };
41948     }
41949   }
41950 }
41951
41952
41953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
41954   void * jresult ;
41955   Dali::EncodedBufferImage *arg1 = 0 ;
41956   Dali::EncodedBufferImage *result = 0 ;
41957
41958   arg1 = (Dali::EncodedBufferImage *)jarg1;
41959   if (!arg1) {
41960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41961     return 0;
41962   }
41963   {
41964     try {
41965       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
41966     } catch (std::out_of_range& e) {
41967       {
41968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41969       };
41970     } catch (std::exception& e) {
41971       {
41972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41973       };
41974     } catch (...) {
41975       {
41976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41977       };
41978     }
41979   }
41980   jresult = (void *)result;
41981   return jresult;
41982 }
41983
41984
41985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
41986   void * jresult ;
41987   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41988   Dali::EncodedBufferImage *arg2 = 0 ;
41989   Dali::EncodedBufferImage *result = 0 ;
41990
41991   arg1 = (Dali::EncodedBufferImage *)jarg1;
41992   arg2 = (Dali::EncodedBufferImage *)jarg2;
41993   if (!arg2) {
41994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41995     return 0;
41996   }
41997   {
41998     try {
41999       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
42000     } catch (std::out_of_range& e) {
42001       {
42002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42003       };
42004     } catch (std::exception& e) {
42005       {
42006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42007       };
42008     } catch (...) {
42009       {
42010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42011       };
42012     }
42013   }
42014   jresult = (void *)result;
42015   return jresult;
42016 }
42017
42018
42019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
42020   void * jresult ;
42021   Dali::NativeImage *result = 0 ;
42022
42023   {
42024     try {
42025       result = (Dali::NativeImage *)new Dali::NativeImage();
42026     } catch (std::out_of_range& e) {
42027       {
42028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42029       };
42030     } catch (std::exception& e) {
42031       {
42032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42033       };
42034     } catch (...) {
42035       {
42036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42037       };
42038     }
42039   }
42040   jresult = (void *)result;
42041   return jresult;
42042 }
42043
42044
42045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
42046   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42047
42048   arg1 = (Dali::NativeImage *)jarg1;
42049   {
42050     try {
42051       delete arg1;
42052     } catch (std::out_of_range& e) {
42053       {
42054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42055       };
42056     } catch (std::exception& e) {
42057       {
42058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42059       };
42060     } catch (...) {
42061       {
42062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42063       };
42064     }
42065   }
42066 }
42067
42068
42069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
42070   void * jresult ;
42071   Dali::NativeImage *arg1 = 0 ;
42072   Dali::NativeImage *result = 0 ;
42073
42074   arg1 = (Dali::NativeImage *)jarg1;
42075   if (!arg1) {
42076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42077     return 0;
42078   }
42079   {
42080     try {
42081       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
42082     } catch (std::out_of_range& e) {
42083       {
42084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42085       };
42086     } catch (std::exception& e) {
42087       {
42088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42089       };
42090     } catch (...) {
42091       {
42092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42093       };
42094     }
42095   }
42096   jresult = (void *)result;
42097   return jresult;
42098 }
42099
42100
42101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
42102   void * jresult ;
42103   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42104   Dali::NativeImage *arg2 = 0 ;
42105   Dali::NativeImage *result = 0 ;
42106
42107   arg1 = (Dali::NativeImage *)jarg1;
42108   arg2 = (Dali::NativeImage *)jarg2;
42109   if (!arg2) {
42110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42111     return 0;
42112   }
42113   {
42114     try {
42115       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
42116     } catch (std::out_of_range& e) {
42117       {
42118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42119       };
42120     } catch (std::exception& e) {
42121       {
42122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42123       };
42124     } catch (...) {
42125       {
42126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42127       };
42128     }
42129   }
42130   jresult = (void *)result;
42131   return jresult;
42132 }
42133
42134
42135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
42136   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42137
42138   arg1 = (Dali::NativeImage *)jarg1;
42139   {
42140     try {
42141       (arg1)->CreateGlTexture();
42142     } catch (std::out_of_range& e) {
42143       {
42144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42145       };
42146     } catch (std::exception& e) {
42147       {
42148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42149       };
42150     } catch (...) {
42151       {
42152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42153       };
42154     }
42155   }
42156 }
42157
42158
42159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
42160   void * jresult ;
42161   NativeImageInterface *arg1 = 0 ;
42162   Dali::NativeImage result;
42163
42164   arg1 = (NativeImageInterface *)jarg1;
42165   if (!arg1) {
42166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
42167     return 0;
42168   }
42169   {
42170     try {
42171       result = Dali::NativeImage::New(*arg1);
42172     } catch (std::out_of_range& e) {
42173       {
42174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42175       };
42176     } catch (std::exception& e) {
42177       {
42178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42179       };
42180     } catch (...) {
42181       {
42182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42183       };
42184     }
42185   }
42186   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42187   return jresult;
42188 }
42189
42190
42191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
42192   void * jresult ;
42193   Dali::BaseHandle arg1 ;
42194   Dali::BaseHandle *argp1 ;
42195   Dali::NativeImage result;
42196
42197   argp1 = (Dali::BaseHandle *)jarg1;
42198   if (!argp1) {
42199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42200     return 0;
42201   }
42202   arg1 = *argp1;
42203   {
42204     try {
42205       result = Dali::NativeImage::DownCast(arg1);
42206     } catch (std::out_of_range& e) {
42207       {
42208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42209       };
42210     } catch (std::exception& e) {
42211       {
42212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42213       };
42214     } catch (...) {
42215       {
42216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42217       };
42218     }
42219   }
42220   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42221   return jresult;
42222 }
42223
42224
42225 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
42226   char * jresult ;
42227   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42228   char *result = 0 ;
42229
42230   arg1 = (Dali::NativeImage *)jarg1;
42231   {
42232     try {
42233       result = (char *)(arg1)->GetCustomFragmentPreFix();
42234     } catch (std::out_of_range& e) {
42235       {
42236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42237       };
42238     } catch (std::exception& e) {
42239       {
42240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42241       };
42242     } catch (...) {
42243       {
42244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42245       };
42246     }
42247   }
42248   jresult = SWIG_csharp_string_callback((const char *)result);
42249   return jresult;
42250 }
42251
42252
42253 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
42254   char * jresult ;
42255   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42256   char *result = 0 ;
42257
42258   arg1 = (Dali::NativeImage *)jarg1;
42259   {
42260     try {
42261       result = (char *)(arg1)->GetCustomSamplerTypename();
42262     } catch (std::out_of_range& e) {
42263       {
42264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42265       };
42266     } catch (std::exception& e) {
42267       {
42268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42269       };
42270     } catch (...) {
42271       {
42272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42273       };
42274     }
42275   }
42276   jresult = SWIG_csharp_string_callback((const char *)result);
42277   return jresult;
42278 }
42279
42280
42281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
42282   unsigned int jresult ;
42283   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42284   bool result;
42285
42286   arg1 = (Dali::NativeImageInterface *)jarg1;
42287   {
42288     try {
42289       result = (bool)(arg1)->GlExtensionCreate();
42290     } catch (std::out_of_range& e) {
42291       {
42292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42293       };
42294     } catch (std::exception& e) {
42295       {
42296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42297       };
42298     } catch (...) {
42299       {
42300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42301       };
42302     }
42303   }
42304   jresult = result;
42305   return jresult;
42306 }
42307
42308
42309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
42310   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42311
42312   arg1 = (Dali::NativeImageInterface *)jarg1;
42313   {
42314     try {
42315       (arg1)->GlExtensionDestroy();
42316     } catch (std::out_of_range& e) {
42317       {
42318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42319       };
42320     } catch (std::exception& e) {
42321       {
42322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42323       };
42324     } catch (...) {
42325       {
42326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42327       };
42328     }
42329   }
42330 }
42331
42332
42333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
42334   unsigned int jresult ;
42335   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42336   unsigned int result;
42337
42338   arg1 = (Dali::NativeImageInterface *)jarg1;
42339   {
42340     try {
42341       result = (unsigned int)(arg1)->TargetTexture();
42342     } catch (std::out_of_range& e) {
42343       {
42344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42345       };
42346     } catch (std::exception& e) {
42347       {
42348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42349       };
42350     } catch (...) {
42351       {
42352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42353       };
42354     }
42355   }
42356   jresult = result;
42357   return jresult;
42358 }
42359
42360
42361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
42362   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42363
42364   arg1 = (Dali::NativeImageInterface *)jarg1;
42365   {
42366     try {
42367       (arg1)->PrepareTexture();
42368     } catch (std::out_of_range& e) {
42369       {
42370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42371       };
42372     } catch (std::exception& e) {
42373       {
42374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42375       };
42376     } catch (...) {
42377       {
42378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42379       };
42380     }
42381   }
42382 }
42383
42384
42385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
42386   unsigned int jresult ;
42387   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42388   unsigned int result;
42389
42390   arg1 = (Dali::NativeImageInterface *)jarg1;
42391   {
42392     try {
42393       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
42394     } catch (std::out_of_range& e) {
42395       {
42396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42397       };
42398     } catch (std::exception& e) {
42399       {
42400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42401       };
42402     } catch (...) {
42403       {
42404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42405       };
42406     }
42407   }
42408   jresult = result;
42409   return jresult;
42410 }
42411
42412
42413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
42414   unsigned int jresult ;
42415   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42416   unsigned int result;
42417
42418   arg1 = (Dali::NativeImageInterface *)jarg1;
42419   {
42420     try {
42421       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
42422     } catch (std::out_of_range& e) {
42423       {
42424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42425       };
42426     } catch (std::exception& e) {
42427       {
42428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42429       };
42430     } catch (...) {
42431       {
42432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42433       };
42434     }
42435   }
42436   jresult = result;
42437   return jresult;
42438 }
42439
42440
42441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
42442   unsigned int jresult ;
42443   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42444   bool result;
42445
42446   arg1 = (Dali::NativeImageInterface *)jarg1;
42447   {
42448     try {
42449       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
42450     } catch (std::out_of_range& e) {
42451       {
42452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42453       };
42454     } catch (std::exception& e) {
42455       {
42456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42457       };
42458     } catch (...) {
42459       {
42460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42461       };
42462     }
42463   }
42464   jresult = result;
42465   return jresult;
42466 }
42467
42468
42469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
42470   void * jresult ;
42471   std::string *arg1 = 0 ;
42472   Dali::ImageDimensions result;
42473
42474   if (!jarg1) {
42475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42476     return 0;
42477   }
42478   std::string arg1_str(jarg1);
42479   arg1 = &arg1_str;
42480   {
42481     try {
42482       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42483     } catch (std::out_of_range& e) {
42484       {
42485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42486       };
42487     } catch (std::exception& e) {
42488       {
42489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42490       };
42491     } catch (...) {
42492       {
42493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42494       };
42495     }
42496   }
42497   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42498
42499   //argout typemap for const std::string&
42500
42501   return jresult;
42502 }
42503
42504
42505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
42506   void * jresult ;
42507   Dali::ResourceImage *result = 0 ;
42508
42509   {
42510     try {
42511       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42512     } catch (std::out_of_range& e) {
42513       {
42514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42515       };
42516     } catch (std::exception& e) {
42517       {
42518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42519       };
42520     } catch (...) {
42521       {
42522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42523       };
42524     }
42525   }
42526   jresult = (void *)result;
42527   return jresult;
42528 }
42529
42530
42531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
42532   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42533
42534   arg1 = (Dali::ResourceImage *)jarg1;
42535   {
42536     try {
42537       delete arg1;
42538     } catch (std::out_of_range& e) {
42539       {
42540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42541       };
42542     } catch (std::exception& e) {
42543       {
42544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42545       };
42546     } catch (...) {
42547       {
42548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42549       };
42550     }
42551   }
42552 }
42553
42554
42555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
42556   void * jresult ;
42557   Dali::ResourceImage *arg1 = 0 ;
42558   Dali::ResourceImage *result = 0 ;
42559
42560   arg1 = (Dali::ResourceImage *)jarg1;
42561   if (!arg1) {
42562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42563     return 0;
42564   }
42565   {
42566     try {
42567       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42568     } catch (std::out_of_range& e) {
42569       {
42570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42571       };
42572     } catch (std::exception& e) {
42573       {
42574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42575       };
42576     } catch (...) {
42577       {
42578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42579       };
42580     }
42581   }
42582   jresult = (void *)result;
42583   return jresult;
42584 }
42585
42586
42587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
42588   void * jresult ;
42589   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42590   Dali::ResourceImage *arg2 = 0 ;
42591   Dali::ResourceImage *result = 0 ;
42592
42593   arg1 = (Dali::ResourceImage *)jarg1;
42594   arg2 = (Dali::ResourceImage *)jarg2;
42595   if (!arg2) {
42596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42597     return 0;
42598   }
42599   {
42600     try {
42601       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42602     } catch (std::out_of_range& e) {
42603       {
42604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42605       };
42606     } catch (std::exception& e) {
42607       {
42608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42609       };
42610     } catch (...) {
42611       {
42612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42613       };
42614     }
42615   }
42616   jresult = (void *)result;
42617   return jresult;
42618 }
42619
42620
42621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42622   void * jresult ;
42623   std::string *arg1 = 0 ;
42624   bool arg2 ;
42625   Dali::ResourceImage result;
42626
42627   if (!jarg1) {
42628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42629     return 0;
42630   }
42631   std::string arg1_str(jarg1);
42632   arg1 = &arg1_str;
42633   arg2 = jarg2 ? true : false;
42634   {
42635     try {
42636       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42637     } catch (std::out_of_range& e) {
42638       {
42639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42640       };
42641     } catch (std::exception& e) {
42642       {
42643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42644       };
42645     } catch (...) {
42646       {
42647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42648       };
42649     }
42650   }
42651   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42652
42653   //argout typemap for const std::string&
42654
42655   return jresult;
42656 }
42657
42658
42659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
42660   void * jresult ;
42661   std::string *arg1 = 0 ;
42662   Dali::ResourceImage result;
42663
42664   if (!jarg1) {
42665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42666     return 0;
42667   }
42668   std::string arg1_str(jarg1);
42669   arg1 = &arg1_str;
42670   {
42671     try {
42672       result = Dali::ResourceImage::New((std::string const &)*arg1);
42673     } catch (std::out_of_range& e) {
42674       {
42675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42676       };
42677     } catch (std::exception& e) {
42678       {
42679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42680       };
42681     } catch (...) {
42682       {
42683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42684       };
42685     }
42686   }
42687   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42688
42689   //argout typemap for const std::string&
42690
42691   return jresult;
42692 }
42693
42694
42695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42696   void * jresult ;
42697   std::string *arg1 = 0 ;
42698   Dali::ImageDimensions arg2 ;
42699   Dali::FittingMode::Type arg3 ;
42700   Dali::SamplingMode::Type arg4 ;
42701   bool arg5 ;
42702   Dali::ImageDimensions *argp2 ;
42703   Dali::ResourceImage result;
42704
42705   if (!jarg1) {
42706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42707     return 0;
42708   }
42709   std::string arg1_str(jarg1);
42710   arg1 = &arg1_str;
42711   argp2 = (Dali::ImageDimensions *)jarg2;
42712   if (!argp2) {
42713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42714     return 0;
42715   }
42716   arg2 = *argp2;
42717   arg3 = (Dali::FittingMode::Type)jarg3;
42718   arg4 = (Dali::SamplingMode::Type)jarg4;
42719   arg5 = jarg5 ? true : false;
42720   {
42721     try {
42722       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42723     } catch (std::out_of_range& e) {
42724       {
42725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42726       };
42727     } catch (std::exception& e) {
42728       {
42729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42730       };
42731     } catch (...) {
42732       {
42733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42734       };
42735     }
42736   }
42737   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42738
42739   //argout typemap for const std::string&
42740
42741   return jresult;
42742 }
42743
42744
42745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42746   void * jresult ;
42747   std::string *arg1 = 0 ;
42748   Dali::ImageDimensions arg2 ;
42749   Dali::FittingMode::Type arg3 ;
42750   Dali::SamplingMode::Type arg4 ;
42751   Dali::ImageDimensions *argp2 ;
42752   Dali::ResourceImage result;
42753
42754   if (!jarg1) {
42755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42756     return 0;
42757   }
42758   std::string arg1_str(jarg1);
42759   arg1 = &arg1_str;
42760   argp2 = (Dali::ImageDimensions *)jarg2;
42761   if (!argp2) {
42762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42763     return 0;
42764   }
42765   arg2 = *argp2;
42766   arg3 = (Dali::FittingMode::Type)jarg3;
42767   arg4 = (Dali::SamplingMode::Type)jarg4;
42768   {
42769     try {
42770       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42771     } catch (std::out_of_range& e) {
42772       {
42773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42774       };
42775     } catch (std::exception& e) {
42776       {
42777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42778       };
42779     } catch (...) {
42780       {
42781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42782       };
42783     }
42784   }
42785   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42786
42787   //argout typemap for const std::string&
42788
42789   return jresult;
42790 }
42791
42792
42793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42794   void * jresult ;
42795   std::string *arg1 = 0 ;
42796   Dali::ImageDimensions arg2 ;
42797   Dali::FittingMode::Type arg3 ;
42798   Dali::ImageDimensions *argp2 ;
42799   Dali::ResourceImage result;
42800
42801   if (!jarg1) {
42802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42803     return 0;
42804   }
42805   std::string arg1_str(jarg1);
42806   arg1 = &arg1_str;
42807   argp2 = (Dali::ImageDimensions *)jarg2;
42808   if (!argp2) {
42809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42810     return 0;
42811   }
42812   arg2 = *argp2;
42813   arg3 = (Dali::FittingMode::Type)jarg3;
42814   {
42815     try {
42816       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42817     } catch (std::out_of_range& e) {
42818       {
42819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42820       };
42821     } catch (std::exception& e) {
42822       {
42823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42824       };
42825     } catch (...) {
42826       {
42827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42828       };
42829     }
42830   }
42831   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42832
42833   //argout typemap for const std::string&
42834
42835   return jresult;
42836 }
42837
42838
42839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42840   void * jresult ;
42841   std::string *arg1 = 0 ;
42842   Dali::ImageDimensions arg2 ;
42843   Dali::ImageDimensions *argp2 ;
42844   Dali::ResourceImage result;
42845
42846   if (!jarg1) {
42847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42848     return 0;
42849   }
42850   std::string arg1_str(jarg1);
42851   arg1 = &arg1_str;
42852   argp2 = (Dali::ImageDimensions *)jarg2;
42853   if (!argp2) {
42854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42855     return 0;
42856   }
42857   arg2 = *argp2;
42858   {
42859     try {
42860       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42861     } catch (std::out_of_range& e) {
42862       {
42863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42864       };
42865     } catch (std::exception& e) {
42866       {
42867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42868       };
42869     } catch (...) {
42870       {
42871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42872       };
42873     }
42874   }
42875   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42876
42877   //argout typemap for const std::string&
42878
42879   return jresult;
42880 }
42881
42882
42883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
42884   void * jresult ;
42885   Dali::BaseHandle arg1 ;
42886   Dali::BaseHandle *argp1 ;
42887   Dali::ResourceImage result;
42888
42889   argp1 = (Dali::BaseHandle *)jarg1;
42890   if (!argp1) {
42891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42892     return 0;
42893   }
42894   arg1 = *argp1;
42895   {
42896     try {
42897       result = Dali::ResourceImage::DownCast(arg1);
42898     } catch (std::out_of_range& e) {
42899       {
42900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42901       };
42902     } catch (std::exception& e) {
42903       {
42904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42905       };
42906     } catch (...) {
42907       {
42908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42909       };
42910     }
42911   }
42912   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42913   return jresult;
42914 }
42915
42916
42917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
42918   int jresult ;
42919   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42920   Dali::LoadingState result;
42921
42922   arg1 = (Dali::ResourceImage *)jarg1;
42923   {
42924     try {
42925       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
42926     } catch (std::out_of_range& e) {
42927       {
42928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42929       };
42930     } catch (std::exception& e) {
42931       {
42932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42933       };
42934     } catch (...) {
42935       {
42936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42937       };
42938     }
42939   }
42940   jresult = (int)result;
42941   return jresult;
42942 }
42943
42944
42945 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
42946   char * jresult ;
42947   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42948   std::string result;
42949
42950   arg1 = (Dali::ResourceImage *)jarg1;
42951   {
42952     try {
42953       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
42954     } catch (std::out_of_range& e) {
42955       {
42956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42957       };
42958     } catch (std::exception& e) {
42959       {
42960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42961       };
42962     } catch (...) {
42963       {
42964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42965       };
42966     }
42967   }
42968   jresult = SWIG_csharp_string_callback((&result)->c_str());
42969   return jresult;
42970 }
42971
42972
42973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
42974   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42975
42976   arg1 = (Dali::ResourceImage *)jarg1;
42977   {
42978     try {
42979       (arg1)->Reload();
42980     } catch (std::out_of_range& e) {
42981       {
42982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42983       };
42984     } catch (std::exception& e) {
42985       {
42986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42987       };
42988     } catch (...) {
42989       {
42990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42991       };
42992     }
42993   }
42994 }
42995
42996
42997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
42998   void * jresult ;
42999   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43000   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
43001
43002   arg1 = (Dali::ResourceImage *)jarg1;
43003   {
43004     try {
43005       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
43006     } catch (std::out_of_range& e) {
43007       {
43008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43009       };
43010     } catch (std::exception& e) {
43011       {
43012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43013       };
43014     } catch (...) {
43015       {
43016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43017       };
43018     }
43019   }
43020   jresult = (void *)result;
43021   return jresult;
43022 }
43023
43024
43025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
43026   void * jresult ;
43027   Dali::FrameBufferImage *result = 0 ;
43028
43029   {
43030     try {
43031       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
43032     } catch (std::out_of_range& e) {
43033       {
43034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43035       };
43036     } catch (std::exception& e) {
43037       {
43038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43039       };
43040     } catch (...) {
43041       {
43042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43043       };
43044     }
43045   }
43046   jresult = (void *)result;
43047   return jresult;
43048 }
43049
43050
43051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
43052   void * jresult ;
43053   unsigned int arg1 ;
43054   unsigned int arg2 ;
43055   Dali::Pixel::Format arg3 ;
43056   Dali::RenderBuffer::Format arg4 ;
43057   Dali::FrameBufferImage result;
43058
43059   arg1 = (unsigned int)jarg1;
43060   arg2 = (unsigned int)jarg2;
43061   arg3 = (Dali::Pixel::Format)jarg3;
43062   arg4 = (Dali::RenderBuffer::Format)jarg4;
43063   {
43064     try {
43065       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
43066     } catch (std::out_of_range& e) {
43067       {
43068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43069       };
43070     } catch (std::exception& e) {
43071       {
43072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43073       };
43074     } catch (...) {
43075       {
43076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43077       };
43078     }
43079   }
43080   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43081   return jresult;
43082 }
43083
43084
43085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
43086   void * jresult ;
43087   unsigned int arg1 ;
43088   unsigned int arg2 ;
43089   Dali::Pixel::Format arg3 ;
43090   Dali::FrameBufferImage result;
43091
43092   arg1 = (unsigned int)jarg1;
43093   arg2 = (unsigned int)jarg2;
43094   arg3 = (Dali::Pixel::Format)jarg3;
43095   {
43096     try {
43097       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
43098     } catch (std::out_of_range& e) {
43099       {
43100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43101       };
43102     } catch (std::exception& e) {
43103       {
43104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43105       };
43106     } catch (...) {
43107       {
43108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43109       };
43110     }
43111   }
43112   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43113   return jresult;
43114 }
43115
43116
43117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
43118   void * jresult ;
43119   unsigned int arg1 ;
43120   unsigned int arg2 ;
43121   Dali::FrameBufferImage result;
43122
43123   arg1 = (unsigned int)jarg1;
43124   arg2 = (unsigned int)jarg2;
43125   {
43126     try {
43127       result = Dali::FrameBufferImage::New(arg1,arg2);
43128     } catch (std::out_of_range& e) {
43129       {
43130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43131       };
43132     } catch (std::exception& e) {
43133       {
43134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43135       };
43136     } catch (...) {
43137       {
43138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43139       };
43140     }
43141   }
43142   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43143   return jresult;
43144 }
43145
43146
43147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
43148   void * jresult ;
43149   unsigned int arg1 ;
43150   Dali::FrameBufferImage result;
43151
43152   arg1 = (unsigned int)jarg1;
43153   {
43154     try {
43155       result = Dali::FrameBufferImage::New(arg1);
43156     } catch (std::out_of_range& e) {
43157       {
43158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43159       };
43160     } catch (std::exception& e) {
43161       {
43162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43163       };
43164     } catch (...) {
43165       {
43166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43167       };
43168     }
43169   }
43170   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43171   return jresult;
43172 }
43173
43174
43175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
43176   void * jresult ;
43177   Dali::FrameBufferImage result;
43178
43179   {
43180     try {
43181       result = Dali::FrameBufferImage::New();
43182     } catch (std::out_of_range& e) {
43183       {
43184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43185       };
43186     } catch (std::exception& e) {
43187       {
43188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43189       };
43190     } catch (...) {
43191       {
43192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43193       };
43194     }
43195   }
43196   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43197   return jresult;
43198 }
43199
43200
43201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
43202   void * jresult ;
43203   Dali::NativeImageInterface *arg1 = 0 ;
43204   Dali::FrameBufferImage result;
43205
43206   arg1 = (Dali::NativeImageInterface *)jarg1;
43207   if (!arg1) {
43208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
43209     return 0;
43210   }
43211   {
43212     try {
43213       result = Dali::FrameBufferImage::New(*arg1);
43214     } catch (std::out_of_range& e) {
43215       {
43216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43217       };
43218     } catch (std::exception& e) {
43219       {
43220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43221       };
43222     } catch (...) {
43223       {
43224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43225       };
43226     }
43227   }
43228   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43229   return jresult;
43230 }
43231
43232
43233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
43234   void * jresult ;
43235   Dali::BaseHandle arg1 ;
43236   Dali::BaseHandle *argp1 ;
43237   Dali::FrameBufferImage result;
43238
43239   argp1 = (Dali::BaseHandle *)jarg1;
43240   if (!argp1) {
43241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43242     return 0;
43243   }
43244   arg1 = *argp1;
43245   {
43246     try {
43247       result = Dali::FrameBufferImage::DownCast(arg1);
43248     } catch (std::out_of_range& e) {
43249       {
43250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43251       };
43252     } catch (std::exception& e) {
43253       {
43254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43255       };
43256     } catch (...) {
43257       {
43258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43259       };
43260     }
43261   }
43262   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43263   return jresult;
43264 }
43265
43266
43267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
43268   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43269
43270   arg1 = (Dali::FrameBufferImage *)jarg1;
43271   {
43272     try {
43273       delete arg1;
43274     } catch (std::out_of_range& e) {
43275       {
43276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43277       };
43278     } catch (std::exception& e) {
43279       {
43280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43281       };
43282     } catch (...) {
43283       {
43284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43285       };
43286     }
43287   }
43288 }
43289
43290
43291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
43292   void * jresult ;
43293   Dali::FrameBufferImage *arg1 = 0 ;
43294   Dali::FrameBufferImage *result = 0 ;
43295
43296   arg1 = (Dali::FrameBufferImage *)jarg1;
43297   if (!arg1) {
43298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43299     return 0;
43300   }
43301   {
43302     try {
43303       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
43304     } catch (std::out_of_range& e) {
43305       {
43306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43307       };
43308     } catch (std::exception& e) {
43309       {
43310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43311       };
43312     } catch (...) {
43313       {
43314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43315       };
43316     }
43317   }
43318   jresult = (void *)result;
43319   return jresult;
43320 }
43321
43322
43323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
43324   void * jresult ;
43325   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43326   Dali::FrameBufferImage *arg2 = 0 ;
43327   Dali::FrameBufferImage *result = 0 ;
43328
43329   arg1 = (Dali::FrameBufferImage *)jarg1;
43330   arg2 = (Dali::FrameBufferImage *)jarg2;
43331   if (!arg2) {
43332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43333     return 0;
43334   }
43335   {
43336     try {
43337       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
43338     } catch (std::out_of_range& e) {
43339       {
43340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43341       };
43342     } catch (std::exception& e) {
43343       {
43344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43345       };
43346     } catch (...) {
43347       {
43348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43349       };
43350     }
43351   }
43352   jresult = (void *)result;
43353   return jresult;
43354 }
43355
43356
43357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
43358   void * jresult ;
43359   Dali::NinePatchImage *result = 0 ;
43360
43361   {
43362     try {
43363       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
43364     } catch (std::out_of_range& e) {
43365       {
43366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43367       };
43368     } catch (std::exception& e) {
43369       {
43370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43371       };
43372     } catch (...) {
43373       {
43374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43375       };
43376     }
43377   }
43378   jresult = (void *)result;
43379   return jresult;
43380 }
43381
43382
43383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
43384   void * jresult ;
43385   std::string *arg1 = 0 ;
43386   Dali::NinePatchImage result;
43387
43388   if (!jarg1) {
43389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43390     return 0;
43391   }
43392   std::string arg1_str(jarg1);
43393   arg1 = &arg1_str;
43394   {
43395     try {
43396       result = Dali::NinePatchImage::New((std::string const &)*arg1);
43397     } catch (std::out_of_range& e) {
43398       {
43399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43400       };
43401     } catch (std::exception& e) {
43402       {
43403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43404       };
43405     } catch (...) {
43406       {
43407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43408       };
43409     }
43410   }
43411   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43412
43413   //argout typemap for const std::string&
43414
43415   return jresult;
43416 }
43417
43418
43419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
43420   void * jresult ;
43421   Dali::BaseHandle arg1 ;
43422   Dali::BaseHandle *argp1 ;
43423   Dali::NinePatchImage result;
43424
43425   argp1 = (Dali::BaseHandle *)jarg1;
43426   if (!argp1) {
43427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43428     return 0;
43429   }
43430   arg1 = *argp1;
43431   {
43432     try {
43433       result = Dali::NinePatchImage::DownCast(arg1);
43434     } catch (std::out_of_range& e) {
43435       {
43436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43437       };
43438     } catch (std::exception& e) {
43439       {
43440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43441       };
43442     } catch (...) {
43443       {
43444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43445       };
43446     }
43447   }
43448   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43449   return jresult;
43450 }
43451
43452
43453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
43454   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43455
43456   arg1 = (Dali::NinePatchImage *)jarg1;
43457   {
43458     try {
43459       delete arg1;
43460     } catch (std::out_of_range& e) {
43461       {
43462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43463       };
43464     } catch (std::exception& e) {
43465       {
43466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43467       };
43468     } catch (...) {
43469       {
43470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43471       };
43472     }
43473   }
43474 }
43475
43476
43477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
43478   void * jresult ;
43479   Dali::NinePatchImage *arg1 = 0 ;
43480   Dali::NinePatchImage *result = 0 ;
43481
43482   arg1 = (Dali::NinePatchImage *)jarg1;
43483   if (!arg1) {
43484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43485     return 0;
43486   }
43487   {
43488     try {
43489       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
43490     } catch (std::out_of_range& e) {
43491       {
43492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43493       };
43494     } catch (std::exception& e) {
43495       {
43496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43497       };
43498     } catch (...) {
43499       {
43500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43501       };
43502     }
43503   }
43504   jresult = (void *)result;
43505   return jresult;
43506 }
43507
43508
43509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43510   void * jresult ;
43511   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43512   Dali::NinePatchImage *arg2 = 0 ;
43513   Dali::NinePatchImage *result = 0 ;
43514
43515   arg1 = (Dali::NinePatchImage *)jarg1;
43516   arg2 = (Dali::NinePatchImage *)jarg2;
43517   if (!arg2) {
43518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43519     return 0;
43520   }
43521   {
43522     try {
43523       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
43524     } catch (std::out_of_range& e) {
43525       {
43526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43527       };
43528     } catch (std::exception& e) {
43529       {
43530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43531       };
43532     } catch (...) {
43533       {
43534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43535       };
43536     }
43537   }
43538   jresult = (void *)result;
43539   return jresult;
43540 }
43541
43542
43543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
43544   void * jresult ;
43545   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43546   Dali::Vector4 result;
43547
43548   arg1 = (Dali::NinePatchImage *)jarg1;
43549   {
43550     try {
43551       result = (arg1)->GetStretchBorders();
43552     } catch (std::out_of_range& e) {
43553       {
43554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43555       };
43556     } catch (std::exception& e) {
43557       {
43558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43559       };
43560     } catch (...) {
43561       {
43562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43563       };
43564     }
43565   }
43566   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43567   return jresult;
43568 }
43569
43570
43571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43572   void * jresult ;
43573   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43574   Dali::NinePatchImage::StretchRanges *result = 0 ;
43575
43576   arg1 = (Dali::NinePatchImage *)jarg1;
43577   {
43578     try {
43579       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43580     } catch (std::out_of_range& e) {
43581       {
43582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43583       };
43584     } catch (std::exception& e) {
43585       {
43586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43587       };
43588     } catch (...) {
43589       {
43590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43591       };
43592     }
43593   }
43594   jresult = (void *)result;
43595   return jresult;
43596 }
43597
43598
43599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43600   void * jresult ;
43601   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43602   Dali::NinePatchImage::StretchRanges *result = 0 ;
43603
43604   arg1 = (Dali::NinePatchImage *)jarg1;
43605   {
43606     try {
43607       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43608     } catch (std::out_of_range& e) {
43609       {
43610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43611       };
43612     } catch (std::exception& e) {
43613       {
43614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43615       };
43616     } catch (...) {
43617       {
43618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43619       };
43620     }
43621   }
43622   jresult = (void *)result;
43623   return jresult;
43624 }
43625
43626
43627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
43628   void * jresult ;
43629   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43630   Dali::Rect< int > result;
43631
43632   arg1 = (Dali::NinePatchImage *)jarg1;
43633   {
43634     try {
43635       result = (arg1)->GetChildRectangle();
43636     } catch (std::out_of_range& e) {
43637       {
43638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43639       };
43640     } catch (std::exception& e) {
43641       {
43642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43643       };
43644     } catch (...) {
43645       {
43646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43647       };
43648     }
43649   }
43650   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43651   return jresult;
43652 }
43653
43654
43655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43656   void * jresult ;
43657   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43658   Dali::BufferImage result;
43659
43660   arg1 = (Dali::NinePatchImage *)jarg1;
43661   {
43662     try {
43663       result = (arg1)->CreateCroppedBufferImage();
43664     } catch (std::out_of_range& e) {
43665       {
43666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43667       };
43668     } catch (std::exception& e) {
43669       {
43670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43671       };
43672     } catch (...) {
43673       {
43674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43675       };
43676     }
43677   }
43678   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43679   return jresult;
43680 }
43681
43682
43683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43684   unsigned int jresult ;
43685   std::string *arg1 = 0 ;
43686   bool result;
43687
43688   if (!jarg1) {
43689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43690     return 0;
43691   }
43692   std::string arg1_str(jarg1);
43693   arg1 = &arg1_str;
43694   {
43695     try {
43696       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43697     } catch (std::out_of_range& e) {
43698       {
43699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43700       };
43701     } catch (std::exception& e) {
43702       {
43703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43704       };
43705     } catch (...) {
43706       {
43707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43708       };
43709     }
43710   }
43711   jresult = result;
43712
43713   //argout typemap for const std::string&
43714
43715   return jresult;
43716 }
43717
43718
43719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
43720   int jresult ;
43721   int result;
43722
43723   result = (int)Dali::CameraActor::Property::TYPE;
43724   jresult = (int)result;
43725   return jresult;
43726 }
43727
43728
43729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
43730   int jresult ;
43731   int result;
43732
43733   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43734   jresult = (int)result;
43735   return jresult;
43736 }
43737
43738
43739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
43740   int jresult ;
43741   int result;
43742
43743   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43744   jresult = (int)result;
43745   return jresult;
43746 }
43747
43748
43749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
43750   int jresult ;
43751   int result;
43752
43753   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43754   jresult = (int)result;
43755   return jresult;
43756 }
43757
43758
43759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43760   int jresult ;
43761   int result;
43762
43763   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43764   jresult = (int)result;
43765   return jresult;
43766 }
43767
43768
43769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43770   int jresult ;
43771   int result;
43772
43773   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43774   jresult = (int)result;
43775   return jresult;
43776 }
43777
43778
43779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43780   int jresult ;
43781   int result;
43782
43783   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43784   jresult = (int)result;
43785   return jresult;
43786 }
43787
43788
43789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43790   int jresult ;
43791   int result;
43792
43793   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43794   jresult = (int)result;
43795   return jresult;
43796 }
43797
43798
43799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43800   int jresult ;
43801   int result;
43802
43803   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43804   jresult = (int)result;
43805   return jresult;
43806 }
43807
43808
43809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43810   int jresult ;
43811   int result;
43812
43813   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43814   jresult = (int)result;
43815   return jresult;
43816 }
43817
43818
43819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
43820   int jresult ;
43821   int result;
43822
43823   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43824   jresult = (int)result;
43825   return jresult;
43826 }
43827
43828
43829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
43830   int jresult ;
43831   int result;
43832
43833   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43834   jresult = (int)result;
43835   return jresult;
43836 }
43837
43838
43839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
43840   int jresult ;
43841   int result;
43842
43843   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43844   jresult = (int)result;
43845   return jresult;
43846 }
43847
43848
43849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
43850   int jresult ;
43851   int result;
43852
43853   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43854   jresult = (int)result;
43855   return jresult;
43856 }
43857
43858
43859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
43860   void * jresult ;
43861   Dali::CameraActor::Property *result = 0 ;
43862
43863   {
43864     try {
43865       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
43866     } catch (std::out_of_range& e) {
43867       {
43868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43869       };
43870     } catch (std::exception& e) {
43871       {
43872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43873       };
43874     } catch (...) {
43875       {
43876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43877       };
43878     }
43879   }
43880   jresult = (void *)result;
43881   return jresult;
43882 }
43883
43884
43885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
43886   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43887
43888   arg1 = (Dali::CameraActor::Property *)jarg1;
43889   {
43890     try {
43891       delete arg1;
43892     } catch (std::out_of_range& e) {
43893       {
43894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43895       };
43896     } catch (std::exception& e) {
43897       {
43898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43899       };
43900     } catch (...) {
43901       {
43902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43903       };
43904     }
43905   }
43906 }
43907
43908
43909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
43910   void * jresult ;
43911   Dali::CameraActor *result = 0 ;
43912
43913   {
43914     try {
43915       result = (Dali::CameraActor *)new Dali::CameraActor();
43916     } catch (std::out_of_range& e) {
43917       {
43918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43919       };
43920     } catch (std::exception& e) {
43921       {
43922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43923       };
43924     } catch (...) {
43925       {
43926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43927       };
43928     }
43929   }
43930   jresult = (void *)result;
43931   return jresult;
43932 }
43933
43934
43935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
43936   void * jresult ;
43937   Dali::CameraActor result;
43938
43939   {
43940     try {
43941       result = Dali::CameraActor::New();
43942     } catch (std::out_of_range& e) {
43943       {
43944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43945       };
43946     } catch (std::exception& e) {
43947       {
43948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43949       };
43950     } catch (...) {
43951       {
43952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43953       };
43954     }
43955   }
43956   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43957   return jresult;
43958 }
43959
43960
43961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
43962   void * jresult ;
43963   Dali::Size *arg1 = 0 ;
43964   Dali::CameraActor result;
43965
43966   arg1 = (Dali::Size *)jarg1;
43967   if (!arg1) {
43968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
43969     return 0;
43970   }
43971   {
43972     try {
43973       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
43974     } catch (std::out_of_range& e) {
43975       {
43976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43977       };
43978     } catch (std::exception& e) {
43979       {
43980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43981       };
43982     } catch (...) {
43983       {
43984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43985       };
43986     }
43987   }
43988   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43989   return jresult;
43990 }
43991
43992
43993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
43994   void * jresult ;
43995   Dali::BaseHandle arg1 ;
43996   Dali::BaseHandle *argp1 ;
43997   Dali::CameraActor result;
43998
43999   argp1 = (Dali::BaseHandle *)jarg1;
44000   if (!argp1) {
44001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44002     return 0;
44003   }
44004   arg1 = *argp1;
44005   {
44006     try {
44007       result = Dali::CameraActor::DownCast(arg1);
44008     } catch (std::out_of_range& e) {
44009       {
44010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44011       };
44012     } catch (std::exception& e) {
44013       {
44014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44015       };
44016     } catch (...) {
44017       {
44018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44019       };
44020     }
44021   }
44022   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44023   return jresult;
44024 }
44025
44026
44027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
44028   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44029
44030   arg1 = (Dali::CameraActor *)jarg1;
44031   {
44032     try {
44033       delete arg1;
44034     } catch (std::out_of_range& e) {
44035       {
44036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44037       };
44038     } catch (std::exception& e) {
44039       {
44040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44041       };
44042     } catch (...) {
44043       {
44044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44045       };
44046     }
44047   }
44048 }
44049
44050
44051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
44052   void * jresult ;
44053   Dali::CameraActor *arg1 = 0 ;
44054   Dali::CameraActor *result = 0 ;
44055
44056   arg1 = (Dali::CameraActor *)jarg1;
44057   if (!arg1) {
44058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44059     return 0;
44060   }
44061   {
44062     try {
44063       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
44064     } catch (std::out_of_range& e) {
44065       {
44066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44067       };
44068     } catch (std::exception& e) {
44069       {
44070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44071       };
44072     } catch (...) {
44073       {
44074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44075       };
44076     }
44077   }
44078   jresult = (void *)result;
44079   return jresult;
44080 }
44081
44082
44083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
44084   void * jresult ;
44085   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44086   Dali::CameraActor *arg2 = 0 ;
44087   Dali::CameraActor *result = 0 ;
44088
44089   arg1 = (Dali::CameraActor *)jarg1;
44090   arg2 = (Dali::CameraActor *)jarg2;
44091   if (!arg2) {
44092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44093     return 0;
44094   }
44095   {
44096     try {
44097       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
44098     } catch (std::out_of_range& e) {
44099       {
44100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44101       };
44102     } catch (std::exception& e) {
44103       {
44104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44105       };
44106     } catch (...) {
44107       {
44108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44109       };
44110     }
44111   }
44112   jresult = (void *)result;
44113   return jresult;
44114 }
44115
44116
44117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
44118   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44119   Dali::Camera::Type arg2 ;
44120
44121   arg1 = (Dali::CameraActor *)jarg1;
44122   arg2 = (Dali::Camera::Type)jarg2;
44123   {
44124     try {
44125       (arg1)->SetType(arg2);
44126     } catch (std::out_of_range& e) {
44127       {
44128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44129       };
44130     } catch (std::exception& e) {
44131       {
44132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44133       };
44134     } catch (...) {
44135       {
44136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44137       };
44138     }
44139   }
44140 }
44141
44142
44143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
44144   int jresult ;
44145   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44146   Dali::Camera::Type result;
44147
44148   arg1 = (Dali::CameraActor *)jarg1;
44149   {
44150     try {
44151       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
44152     } catch (std::out_of_range& e) {
44153       {
44154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44155       };
44156     } catch (std::exception& e) {
44157       {
44158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44159       };
44160     } catch (...) {
44161       {
44162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44163       };
44164     }
44165   }
44166   jresult = (int)result;
44167   return jresult;
44168 }
44169
44170
44171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
44172   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44173   Dali::Camera::ProjectionMode arg2 ;
44174
44175   arg1 = (Dali::CameraActor *)jarg1;
44176   arg2 = (Dali::Camera::ProjectionMode)jarg2;
44177   {
44178     try {
44179       (arg1)->SetProjectionMode(arg2);
44180     } catch (std::out_of_range& e) {
44181       {
44182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44183       };
44184     } catch (std::exception& e) {
44185       {
44186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44187       };
44188     } catch (...) {
44189       {
44190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44191       };
44192     }
44193   }
44194 }
44195
44196
44197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
44198   int jresult ;
44199   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44200   Dali::Camera::ProjectionMode result;
44201
44202   arg1 = (Dali::CameraActor *)jarg1;
44203   {
44204     try {
44205       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
44206     } catch (std::out_of_range& e) {
44207       {
44208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44209       };
44210     } catch (std::exception& e) {
44211       {
44212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44213       };
44214     } catch (...) {
44215       {
44216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44217       };
44218     }
44219   }
44220   jresult = (int)result;
44221   return jresult;
44222 }
44223
44224
44225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
44226   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44227   float arg2 ;
44228
44229   arg1 = (Dali::CameraActor *)jarg1;
44230   arg2 = (float)jarg2;
44231   {
44232     try {
44233       (arg1)->SetFieldOfView(arg2);
44234     } catch (std::out_of_range& e) {
44235       {
44236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44237       };
44238     } catch (std::exception& e) {
44239       {
44240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44241       };
44242     } catch (...) {
44243       {
44244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44245       };
44246     }
44247   }
44248 }
44249
44250
44251 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
44252   float jresult ;
44253   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44254   float result;
44255
44256   arg1 = (Dali::CameraActor *)jarg1;
44257   {
44258     try {
44259       result = (float)(arg1)->GetFieldOfView();
44260     } catch (std::out_of_range& e) {
44261       {
44262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44263       };
44264     } catch (std::exception& e) {
44265       {
44266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44267       };
44268     } catch (...) {
44269       {
44270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44271       };
44272     }
44273   }
44274   jresult = result;
44275   return jresult;
44276 }
44277
44278
44279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
44280   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44281   float arg2 ;
44282
44283   arg1 = (Dali::CameraActor *)jarg1;
44284   arg2 = (float)jarg2;
44285   {
44286     try {
44287       (arg1)->SetAspectRatio(arg2);
44288     } catch (std::out_of_range& e) {
44289       {
44290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44291       };
44292     } catch (std::exception& e) {
44293       {
44294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44295       };
44296     } catch (...) {
44297       {
44298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44299       };
44300     }
44301   }
44302 }
44303
44304
44305 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
44306   float jresult ;
44307   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44308   float result;
44309
44310   arg1 = (Dali::CameraActor *)jarg1;
44311   {
44312     try {
44313       result = (float)(arg1)->GetAspectRatio();
44314     } catch (std::out_of_range& e) {
44315       {
44316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44317       };
44318     } catch (std::exception& e) {
44319       {
44320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44321       };
44322     } catch (...) {
44323       {
44324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44325       };
44326     }
44327   }
44328   jresult = result;
44329   return jresult;
44330 }
44331
44332
44333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
44334   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44335   float arg2 ;
44336
44337   arg1 = (Dali::CameraActor *)jarg1;
44338   arg2 = (float)jarg2;
44339   {
44340     try {
44341       (arg1)->SetNearClippingPlane(arg2);
44342     } catch (std::out_of_range& e) {
44343       {
44344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44345       };
44346     } catch (std::exception& e) {
44347       {
44348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44349       };
44350     } catch (...) {
44351       {
44352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44353       };
44354     }
44355   }
44356 }
44357
44358
44359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
44360   float jresult ;
44361   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44362   float result;
44363
44364   arg1 = (Dali::CameraActor *)jarg1;
44365   {
44366     try {
44367       result = (float)(arg1)->GetNearClippingPlane();
44368     } catch (std::out_of_range& e) {
44369       {
44370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44371       };
44372     } catch (std::exception& e) {
44373       {
44374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44375       };
44376     } catch (...) {
44377       {
44378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44379       };
44380     }
44381   }
44382   jresult = result;
44383   return jresult;
44384 }
44385
44386
44387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
44388   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44389   float arg2 ;
44390
44391   arg1 = (Dali::CameraActor *)jarg1;
44392   arg2 = (float)jarg2;
44393   {
44394     try {
44395       (arg1)->SetFarClippingPlane(arg2);
44396     } catch (std::out_of_range& e) {
44397       {
44398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44399       };
44400     } catch (std::exception& e) {
44401       {
44402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44403       };
44404     } catch (...) {
44405       {
44406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44407       };
44408     }
44409   }
44410 }
44411
44412
44413 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
44414   float jresult ;
44415   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44416   float result;
44417
44418   arg1 = (Dali::CameraActor *)jarg1;
44419   {
44420     try {
44421       result = (float)(arg1)->GetFarClippingPlane();
44422     } catch (std::out_of_range& e) {
44423       {
44424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44425       };
44426     } catch (std::exception& e) {
44427       {
44428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44429       };
44430     } catch (...) {
44431       {
44432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44433       };
44434     }
44435   }
44436   jresult = result;
44437   return jresult;
44438 }
44439
44440
44441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
44442   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44443   Dali::Vector3 *arg2 = 0 ;
44444
44445   arg1 = (Dali::CameraActor *)jarg1;
44446   arg2 = (Dali::Vector3 *)jarg2;
44447   if (!arg2) {
44448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44449     return ;
44450   }
44451   {
44452     try {
44453       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
44454     } catch (std::out_of_range& e) {
44455       {
44456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44457       };
44458     } catch (std::exception& e) {
44459       {
44460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44461       };
44462     } catch (...) {
44463       {
44464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44465       };
44466     }
44467   }
44468 }
44469
44470
44471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
44472   void * jresult ;
44473   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44474   Dali::Vector3 result;
44475
44476   arg1 = (Dali::CameraActor *)jarg1;
44477   {
44478     try {
44479       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
44480     } catch (std::out_of_range& e) {
44481       {
44482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44483       };
44484     } catch (std::exception& e) {
44485       {
44486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44487       };
44488     } catch (...) {
44489       {
44490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44491       };
44492     }
44493   }
44494   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44495   return jresult;
44496 }
44497
44498
44499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44500   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44501   bool arg2 ;
44502
44503   arg1 = (Dali::CameraActor *)jarg1;
44504   arg2 = jarg2 ? true : false;
44505   {
44506     try {
44507       (arg1)->SetInvertYAxis(arg2);
44508     } catch (std::out_of_range& e) {
44509       {
44510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44511       };
44512     } catch (std::exception& e) {
44513       {
44514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44515       };
44516     } catch (...) {
44517       {
44518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44519       };
44520     }
44521   }
44522 }
44523
44524
44525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
44526   unsigned int jresult ;
44527   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44528   bool result;
44529
44530   arg1 = (Dali::CameraActor *)jarg1;
44531   {
44532     try {
44533       result = (bool)(arg1)->GetInvertYAxis();
44534     } catch (std::out_of_range& e) {
44535       {
44536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44537       };
44538     } catch (std::exception& e) {
44539       {
44540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44541       };
44542     } catch (...) {
44543       {
44544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44545       };
44546     }
44547   }
44548   jresult = result;
44549   return jresult;
44550 }
44551
44552
44553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44554   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44555   Dali::Size *arg2 = 0 ;
44556
44557   arg1 = (Dali::CameraActor *)jarg1;
44558   arg2 = (Dali::Size *)jarg2;
44559   if (!arg2) {
44560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44561     return ;
44562   }
44563   {
44564     try {
44565       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44566     } catch (std::out_of_range& e) {
44567       {
44568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44569       };
44570     } catch (std::exception& e) {
44571       {
44572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44573       };
44574     } catch (...) {
44575       {
44576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44577       };
44578     }
44579   }
44580 }
44581
44582
44583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44584   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44585   Dali::Size *arg2 = 0 ;
44586
44587   arg1 = (Dali::CameraActor *)jarg1;
44588   arg2 = (Dali::Size *)jarg2;
44589   if (!arg2) {
44590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44591     return ;
44592   }
44593   {
44594     try {
44595       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44596     } catch (std::out_of_range& e) {
44597       {
44598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44599       };
44600     } catch (std::exception& e) {
44601       {
44602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44603       };
44604     } catch (...) {
44605       {
44606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44607       };
44608     }
44609   }
44610 }
44611
44612
44613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44614   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44615   float arg2 ;
44616   float arg3 ;
44617   float arg4 ;
44618   float arg5 ;
44619   float arg6 ;
44620   float arg7 ;
44621
44622   arg1 = (Dali::CameraActor *)jarg1;
44623   arg2 = (float)jarg2;
44624   arg3 = (float)jarg3;
44625   arg4 = (float)jarg4;
44626   arg5 = (float)jarg5;
44627   arg6 = (float)jarg6;
44628   arg7 = (float)jarg7;
44629   {
44630     try {
44631       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
44632     } catch (std::out_of_range& e) {
44633       {
44634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44635       };
44636     } catch (std::exception& e) {
44637       {
44638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44639       };
44640     } catch (...) {
44641       {
44642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44643       };
44644     }
44645   }
44646 }
44647
44648
44649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
44650   void * jresult ;
44651   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44652
44653   {
44654     try {
44655       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44656     } catch (std::out_of_range& e) {
44657       {
44658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44659       };
44660     } catch (std::exception& e) {
44661       {
44662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44663       };
44664     } catch (...) {
44665       {
44666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44667       };
44668     }
44669   }
44670   jresult = (void *)result;
44671   return jresult;
44672 }
44673
44674
44675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44676   void * jresult ;
44677   std::string arg1 ;
44678   Dali::Property::Value arg2 ;
44679   Dali::Property::Value *argp2 ;
44680   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44681
44682   if (!jarg1) {
44683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44684     return 0;
44685   }
44686   (&arg1)->assign(jarg1);
44687   argp2 = (Dali::Property::Value *)jarg2;
44688   if (!argp2) {
44689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44690     return 0;
44691   }
44692   arg2 = *argp2;
44693   {
44694     try {
44695       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44696     } catch (std::out_of_range& e) {
44697       {
44698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44699       };
44700     } catch (std::exception& e) {
44701       {
44702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44703       };
44704     } catch (...) {
44705       {
44706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44707       };
44708     }
44709   }
44710   jresult = (void *)result;
44711   return jresult;
44712 }
44713
44714
44715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
44716   void * jresult ;
44717   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44718   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44719
44720   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44721   if (!arg1) {
44722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44723     return 0;
44724   }
44725   {
44726     try {
44727       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);
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 = (void *)result;
44743   return jresult;
44744 }
44745
44746
44747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
44748   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44749   std::string *arg2 = 0 ;
44750
44751   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44752   if (!jarg2) {
44753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44754     return ;
44755   }
44756   std::string arg2_str(jarg2);
44757   arg2 = &arg2_str;
44758   if (arg1) (arg1)->first = *arg2;
44759
44760   //argout typemap for const std::string&
44761
44762 }
44763
44764
44765 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
44766   char * jresult ;
44767   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44768   std::string *result = 0 ;
44769
44770   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44771   result = (std::string *) & ((arg1)->first);
44772   jresult = SWIG_csharp_string_callback(result->c_str());
44773   return jresult;
44774 }
44775
44776
44777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
44778   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44779   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44780
44781   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44782   arg2 = (Dali::Property::Value *)jarg2;
44783   if (arg1) (arg1)->second = *arg2;
44784 }
44785
44786
44787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
44788   void * jresult ;
44789   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44790   Dali::Property::Value *result = 0 ;
44791
44792   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44793   result = (Dali::Property::Value *)& ((arg1)->second);
44794   jresult = (void *)result;
44795   return jresult;
44796 }
44797
44798
44799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
44800   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44801
44802   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44803   {
44804     try {
44805       delete arg1;
44806     } catch (std::out_of_range& e) {
44807       {
44808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44809       };
44810     } catch (std::exception& e) {
44811       {
44812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44813       };
44814     } catch (...) {
44815       {
44816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44817       };
44818     }
44819   }
44820 }
44821
44822
44823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
44824   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44825
44826   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44827   {
44828     try {
44829       (arg1)->clear();
44830     } catch (std::out_of_range& e) {
44831       {
44832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44833       };
44834     } catch (std::exception& e) {
44835       {
44836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44837       };
44838     } catch (...) {
44839       {
44840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44841       };
44842     }
44843   }
44844 }
44845
44846
44847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44848   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44849   Dali::TouchPoint *arg2 = 0 ;
44850
44851   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44852   arg2 = (Dali::TouchPoint *)jarg2;
44853   if (!arg2) {
44854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44855     return ;
44856   }
44857   {
44858     try {
44859       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44860     } catch (std::out_of_range& e) {
44861       {
44862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44863       };
44864     } catch (std::exception& e) {
44865       {
44866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44867       };
44868     } catch (...) {
44869       {
44870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44871       };
44872     }
44873   }
44874 }
44875
44876
44877 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
44878   unsigned long jresult ;
44879   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44880   std::vector< Dali::TouchPoint >::size_type result;
44881
44882   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44883   {
44884     try {
44885       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44886     } catch (std::out_of_range& e) {
44887       {
44888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44889       };
44890     } catch (std::exception& e) {
44891       {
44892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44893       };
44894     } catch (...) {
44895       {
44896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44897       };
44898     }
44899   }
44900   jresult = (unsigned long)result;
44901   return jresult;
44902 }
44903
44904
44905 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
44906   unsigned long jresult ;
44907   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44908   std::vector< Dali::TouchPoint >::size_type result;
44909
44910   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44911   {
44912     try {
44913       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
44914     } catch (std::out_of_range& e) {
44915       {
44916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44917       };
44918     } catch (std::exception& e) {
44919       {
44920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44921       };
44922     } catch (...) {
44923       {
44924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44925       };
44926     }
44927   }
44928   jresult = (unsigned long)result;
44929   return jresult;
44930 }
44931
44932
44933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
44934   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44935   std::vector< Dali::TouchPoint >::size_type arg2 ;
44936
44937   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44938   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
44939   {
44940     try {
44941       (arg1)->reserve(arg2);
44942     } catch (std::out_of_range& e) {
44943       {
44944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44945       };
44946     } catch (std::exception& e) {
44947       {
44948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44949       };
44950     } catch (...) {
44951       {
44952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44953       };
44954     }
44955   }
44956 }
44957
44958
44959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
44960   void * jresult ;
44961   std::vector< Dali::TouchPoint > *result = 0 ;
44962
44963   {
44964     try {
44965       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
44966     } catch (std::out_of_range& e) {
44967       {
44968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44969       };
44970     } catch (std::exception& e) {
44971       {
44972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44973       };
44974     } catch (...) {
44975       {
44976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44977       };
44978     }
44979   }
44980   jresult = (void *)result;
44981   return jresult;
44982 }
44983
44984
44985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
44986   void * jresult ;
44987   std::vector< Dali::TouchPoint > *arg1 = 0 ;
44988   std::vector< Dali::TouchPoint > *result = 0 ;
44989
44990   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44991   if (!arg1) {
44992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
44993     return 0;
44994   }
44995   {
44996     try {
44997       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
44998     } catch (std::out_of_range& e) {
44999       {
45000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45001       };
45002     } catch (std::exception& e) {
45003       {
45004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45005       };
45006     } catch (...) {
45007       {
45008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45009       };
45010     }
45011   }
45012   jresult = (void *)result;
45013   return jresult;
45014 }
45015
45016
45017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
45018   void * jresult ;
45019   int arg1 ;
45020   std::vector< Dali::TouchPoint > *result = 0 ;
45021
45022   arg1 = (int)jarg1;
45023   {
45024     try {
45025       try {
45026         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
45027       }
45028       catch(std::out_of_range &_e) {
45029         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45030         return 0;
45031       }
45032
45033     } catch (std::out_of_range& e) {
45034       {
45035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45036       };
45037     } catch (std::exception& e) {
45038       {
45039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45040       };
45041     } catch (...) {
45042       {
45043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45044       };
45045     }
45046   }
45047   jresult = (void *)result;
45048   return jresult;
45049 }
45050
45051
45052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
45053   void * jresult ;
45054   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45055   int arg2 ;
45056   SwigValueWrapper< Dali::TouchPoint > result;
45057
45058   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45059   arg2 = (int)jarg2;
45060   {
45061     try {
45062       try {
45063         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
45064       }
45065       catch(std::out_of_range &_e) {
45066         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45067         return 0;
45068       }
45069
45070     } catch (std::out_of_range& e) {
45071       {
45072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45073       };
45074     } catch (std::exception& e) {
45075       {
45076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45077       };
45078     } catch (...) {
45079       {
45080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45081       };
45082     }
45083   }
45084   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
45085   return jresult;
45086 }
45087
45088
45089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
45090   void * jresult ;
45091   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45092   int arg2 ;
45093   Dali::TouchPoint *result = 0 ;
45094
45095   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45096   arg2 = (int)jarg2;
45097   {
45098     try {
45099       try {
45100         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
45101       }
45102       catch(std::out_of_range &_e) {
45103         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45104         return 0;
45105       }
45106
45107     } catch (std::out_of_range& e) {
45108       {
45109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45110       };
45111     } catch (std::exception& e) {
45112       {
45113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45114       };
45115     } catch (...) {
45116       {
45117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45118       };
45119     }
45120   }
45121   jresult = (void *)result;
45122   return jresult;
45123 }
45124
45125
45126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
45127   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45128   int arg2 ;
45129   Dali::TouchPoint *arg3 = 0 ;
45130
45131   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45132   arg2 = (int)jarg2;
45133   arg3 = (Dali::TouchPoint *)jarg3;
45134   if (!arg3) {
45135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45136     return ;
45137   }
45138   {
45139     try {
45140       try {
45141         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45142       }
45143       catch(std::out_of_range &_e) {
45144         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45145         return ;
45146       }
45147
45148     } catch (std::out_of_range& e) {
45149       {
45150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45151       };
45152     } catch (std::exception& e) {
45153       {
45154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45155       };
45156     } catch (...) {
45157       {
45158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45159       };
45160     }
45161   }
45162 }
45163
45164
45165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
45166   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45167   std::vector< Dali::TouchPoint > *arg2 = 0 ;
45168
45169   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45170   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
45171   if (!arg2) {
45172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45173     return ;
45174   }
45175   {
45176     try {
45177       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
45178     } catch (std::out_of_range& e) {
45179       {
45180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45181       };
45182     } catch (std::exception& e) {
45183       {
45184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45185       };
45186     } catch (...) {
45187       {
45188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45189       };
45190     }
45191   }
45192 }
45193
45194
45195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
45196   void * jresult ;
45197   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45198   int arg2 ;
45199   int arg3 ;
45200   std::vector< Dali::TouchPoint > *result = 0 ;
45201
45202   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45203   arg2 = (int)jarg2;
45204   arg3 = (int)jarg3;
45205   {
45206     try {
45207       try {
45208         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
45209       }
45210       catch(std::out_of_range &_e) {
45211         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45212         return 0;
45213       }
45214       catch(std::invalid_argument &_e) {
45215         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45216         return 0;
45217       }
45218
45219     } catch (std::out_of_range& e) {
45220       {
45221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45222       };
45223     } catch (std::exception& e) {
45224       {
45225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45226       };
45227     } catch (...) {
45228       {
45229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45230       };
45231     }
45232   }
45233   jresult = (void *)result;
45234   return jresult;
45235 }
45236
45237
45238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
45239   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45240   int arg2 ;
45241   Dali::TouchPoint *arg3 = 0 ;
45242
45243   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45244   arg2 = (int)jarg2;
45245   arg3 = (Dali::TouchPoint *)jarg3;
45246   if (!arg3) {
45247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45248     return ;
45249   }
45250   {
45251     try {
45252       try {
45253         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45254       }
45255       catch(std::out_of_range &_e) {
45256         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45257         return ;
45258       }
45259
45260     } catch (std::out_of_range& e) {
45261       {
45262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45263       };
45264     } catch (std::exception& e) {
45265       {
45266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45267       };
45268     } catch (...) {
45269       {
45270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45271       };
45272     }
45273   }
45274 }
45275
45276
45277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
45278   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45279   int arg2 ;
45280   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45281
45282   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45283   arg2 = (int)jarg2;
45284   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45285   if (!arg3) {
45286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45287     return ;
45288   }
45289   {
45290     try {
45291       try {
45292         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45293       }
45294       catch(std::out_of_range &_e) {
45295         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45296         return ;
45297       }
45298
45299     } catch (std::out_of_range& e) {
45300       {
45301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45302       };
45303     } catch (std::exception& e) {
45304       {
45305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45306       };
45307     } catch (...) {
45308       {
45309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45310       };
45311     }
45312   }
45313 }
45314
45315
45316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
45317   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45318   int arg2 ;
45319
45320   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45321   arg2 = (int)jarg2;
45322   {
45323     try {
45324       try {
45325         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
45326       }
45327       catch(std::out_of_range &_e) {
45328         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45329         return ;
45330       }
45331
45332     } catch (std::out_of_range& e) {
45333       {
45334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45335       };
45336     } catch (std::exception& e) {
45337       {
45338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45339       };
45340     } catch (...) {
45341       {
45342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45343       };
45344     }
45345   }
45346 }
45347
45348
45349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
45350   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45351   int arg2 ;
45352   int arg3 ;
45353
45354   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45355   arg2 = (int)jarg2;
45356   arg3 = (int)jarg3;
45357   {
45358     try {
45359       try {
45360         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
45361       }
45362       catch(std::out_of_range &_e) {
45363         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45364         return ;
45365       }
45366       catch(std::invalid_argument &_e) {
45367         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45368         return ;
45369       }
45370
45371     } catch (std::out_of_range& e) {
45372       {
45373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45374       };
45375     } catch (std::exception& e) {
45376       {
45377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45378       };
45379     } catch (...) {
45380       {
45381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45382       };
45383     }
45384   }
45385 }
45386
45387
45388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
45389   void * jresult ;
45390   Dali::TouchPoint *arg1 = 0 ;
45391   int arg2 ;
45392   std::vector< Dali::TouchPoint > *result = 0 ;
45393
45394   arg1 = (Dali::TouchPoint *)jarg1;
45395   if (!arg1) {
45396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45397     return 0;
45398   }
45399   arg2 = (int)jarg2;
45400   {
45401     try {
45402       try {
45403         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
45404       }
45405       catch(std::out_of_range &_e) {
45406         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45407         return 0;
45408       }
45409
45410     } catch (std::out_of_range& e) {
45411       {
45412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45413       };
45414     } catch (std::exception& e) {
45415       {
45416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45417       };
45418     } catch (...) {
45419       {
45420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45421       };
45422     }
45423   }
45424   jresult = (void *)result;
45425   return jresult;
45426 }
45427
45428
45429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
45430   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45431
45432   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45433   {
45434     try {
45435       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
45436     } catch (std::out_of_range& e) {
45437       {
45438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45439       };
45440     } catch (std::exception& e) {
45441       {
45442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45443       };
45444     } catch (...) {
45445       {
45446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45447       };
45448     }
45449   }
45450 }
45451
45452
45453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
45454   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45455   int arg2 ;
45456   int arg3 ;
45457
45458   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45459   arg2 = (int)jarg2;
45460   arg3 = (int)jarg3;
45461   {
45462     try {
45463       try {
45464         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
45465       }
45466       catch(std::out_of_range &_e) {
45467         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45468         return ;
45469       }
45470       catch(std::invalid_argument &_e) {
45471         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45472         return ;
45473       }
45474
45475     } catch (std::out_of_range& e) {
45476       {
45477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45478       };
45479     } catch (std::exception& e) {
45480       {
45481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45482       };
45483     } catch (...) {
45484       {
45485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45486       };
45487     }
45488   }
45489 }
45490
45491
45492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45493   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45494   int arg2 ;
45495   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45496
45497   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45498   arg2 = (int)jarg2;
45499   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45500   if (!arg3) {
45501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45502     return ;
45503   }
45504   {
45505     try {
45506       try {
45507         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45508       }
45509       catch(std::out_of_range &_e) {
45510         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45511         return ;
45512       }
45513
45514     } catch (std::out_of_range& e) {
45515       {
45516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45517       };
45518     } catch (std::exception& e) {
45519       {
45520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45521       };
45522     } catch (...) {
45523       {
45524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45525       };
45526     }
45527   }
45528 }
45529
45530
45531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
45532   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45533
45534   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45535   {
45536     try {
45537       delete arg1;
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 void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
45556   void * jresult ;
45557   Dali::Rect< int > *result = 0 ;
45558
45559   {
45560     try {
45561       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45562     } catch (std::out_of_range& e) {
45563       {
45564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45565       };
45566     } catch (std::exception& e) {
45567       {
45568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45569       };
45570     } catch (...) {
45571       {
45572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45573       };
45574     }
45575   }
45576   jresult = (void *)result;
45577   return jresult;
45578 }
45579
45580
45581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45582   void * jresult ;
45583   int arg1 ;
45584   int arg2 ;
45585   int arg3 ;
45586   int arg4 ;
45587   Dali::Rect< int > *result = 0 ;
45588
45589   arg1 = (int)jarg1;
45590   arg2 = (int)jarg2;
45591   arg3 = (int)jarg3;
45592   arg4 = (int)jarg4;
45593   {
45594     try {
45595       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45596     } catch (std::out_of_range& e) {
45597       {
45598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45599       };
45600     } catch (std::exception& e) {
45601       {
45602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45603       };
45604     } catch (...) {
45605       {
45606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45607       };
45608     }
45609   }
45610   jresult = (void *)result;
45611   return jresult;
45612 }
45613
45614
45615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
45616   void * jresult ;
45617   Dali::Rect< int > *arg1 = 0 ;
45618   Dali::Rect< int > *result = 0 ;
45619
45620   arg1 = (Dali::Rect< int > *)jarg1;
45621   if (!arg1) {
45622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45623     return 0;
45624   }
45625   {
45626     try {
45627       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45628     } catch (std::out_of_range& e) {
45629       {
45630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45631       };
45632     } catch (std::exception& e) {
45633       {
45634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45635       };
45636     } catch (...) {
45637       {
45638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45639       };
45640     }
45641   }
45642   jresult = (void *)result;
45643   return jresult;
45644 }
45645
45646
45647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
45648   void * jresult ;
45649   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45650   Dali::Rect< int > *arg2 = 0 ;
45651   Dali::Rect< int > *result = 0 ;
45652
45653   arg1 = (Dali::Rect< int > *)jarg1;
45654   arg2 = (Dali::Rect< int > *)jarg2;
45655   if (!arg2) {
45656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45657     return 0;
45658   }
45659   {
45660     try {
45661       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
45662     } catch (std::out_of_range& e) {
45663       {
45664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45665       };
45666     } catch (std::exception& e) {
45667       {
45668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45669       };
45670     } catch (...) {
45671       {
45672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45673       };
45674     }
45675   }
45676   jresult = (void *)result;
45677   return jresult;
45678 }
45679
45680
45681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45682   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45683   int arg2 ;
45684   int arg3 ;
45685   int arg4 ;
45686   int arg5 ;
45687
45688   arg1 = (Dali::Rect< int > *)jarg1;
45689   arg2 = (int)jarg2;
45690   arg3 = (int)jarg3;
45691   arg4 = (int)jarg4;
45692   arg5 = (int)jarg5;
45693   {
45694     try {
45695       (arg1)->Set(arg2,arg3,arg4,arg5);
45696     } catch (std::out_of_range& e) {
45697       {
45698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45699       };
45700     } catch (std::exception& e) {
45701       {
45702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45703       };
45704     } catch (...) {
45705       {
45706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45707       };
45708     }
45709   }
45710 }
45711
45712
45713 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
45714   unsigned int jresult ;
45715   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45716   bool result;
45717
45718   arg1 = (Dali::Rect< int > *)jarg1;
45719   {
45720     try {
45721       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
45722     } catch (std::out_of_range& e) {
45723       {
45724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45725       };
45726     } catch (std::exception& e) {
45727       {
45728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45729       };
45730     } catch (...) {
45731       {
45732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45733       };
45734     }
45735   }
45736   jresult = result;
45737   return jresult;
45738 }
45739
45740
45741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
45742   int jresult ;
45743   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45744   int result;
45745
45746   arg1 = (Dali::Rect< int > *)jarg1;
45747   {
45748     try {
45749       result = (int)((Dali::Rect< int > const *)arg1)->Left();
45750     } catch (std::out_of_range& e) {
45751       {
45752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45753       };
45754     } catch (std::exception& e) {
45755       {
45756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45757       };
45758     } catch (...) {
45759       {
45760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45761       };
45762     }
45763   }
45764   jresult = result;
45765   return jresult;
45766 }
45767
45768
45769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
45770   int jresult ;
45771   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45772   int result;
45773
45774   arg1 = (Dali::Rect< int > *)jarg1;
45775   {
45776     try {
45777       result = (int)((Dali::Rect< int > const *)arg1)->Right();
45778     } catch (std::out_of_range& e) {
45779       {
45780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45781       };
45782     } catch (std::exception& e) {
45783       {
45784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45785       };
45786     } catch (...) {
45787       {
45788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45789       };
45790     }
45791   }
45792   jresult = result;
45793   return jresult;
45794 }
45795
45796
45797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
45798   int jresult ;
45799   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45800   int result;
45801
45802   arg1 = (Dali::Rect< int > *)jarg1;
45803   {
45804     try {
45805       result = (int)((Dali::Rect< int > const *)arg1)->Top();
45806     } catch (std::out_of_range& e) {
45807       {
45808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45809       };
45810     } catch (std::exception& e) {
45811       {
45812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45813       };
45814     } catch (...) {
45815       {
45816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45817       };
45818     }
45819   }
45820   jresult = result;
45821   return jresult;
45822 }
45823
45824
45825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
45826   int jresult ;
45827   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45828   int result;
45829
45830   arg1 = (Dali::Rect< int > *)jarg1;
45831   {
45832     try {
45833       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
45834     } catch (std::out_of_range& e) {
45835       {
45836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45837       };
45838     } catch (std::exception& e) {
45839       {
45840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45841       };
45842     } catch (...) {
45843       {
45844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45845       };
45846     }
45847   }
45848   jresult = result;
45849   return jresult;
45850 }
45851
45852
45853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
45854   int jresult ;
45855   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45856   int result;
45857
45858   arg1 = (Dali::Rect< int > *)jarg1;
45859   {
45860     try {
45861       result = (int)((Dali::Rect< int > const *)arg1)->Area();
45862     } catch (std::out_of_range& e) {
45863       {
45864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45865       };
45866     } catch (std::exception& e) {
45867       {
45868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45869       };
45870     } catch (...) {
45871       {
45872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45873       };
45874     }
45875   }
45876   jresult = result;
45877   return jresult;
45878 }
45879
45880
45881 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
45882   unsigned int jresult ;
45883   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45884   Dali::Rect< int > *arg2 = 0 ;
45885   bool result;
45886
45887   arg1 = (Dali::Rect< int > *)jarg1;
45888   arg2 = (Dali::Rect< int > *)jarg2;
45889   if (!arg2) {
45890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45891     return 0;
45892   }
45893   {
45894     try {
45895       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
45896     } catch (std::out_of_range& e) {
45897       {
45898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45899       };
45900     } catch (std::exception& e) {
45901       {
45902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45903       };
45904     } catch (...) {
45905       {
45906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45907       };
45908     }
45909   }
45910   jresult = result;
45911   return jresult;
45912 }
45913
45914
45915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
45916   unsigned int jresult ;
45917   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45918   Dali::Rect< int > *arg2 = 0 ;
45919   bool result;
45920
45921   arg1 = (Dali::Rect< int > *)jarg1;
45922   arg2 = (Dali::Rect< int > *)jarg2;
45923   if (!arg2) {
45924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45925     return 0;
45926   }
45927   {
45928     try {
45929       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
45930     } catch (std::out_of_range& e) {
45931       {
45932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45933       };
45934     } catch (std::exception& e) {
45935       {
45936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45937       };
45938     } catch (...) {
45939       {
45940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45941       };
45942     }
45943   }
45944   jresult = result;
45945   return jresult;
45946 }
45947
45948
45949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
45950   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45951   int arg2 ;
45952
45953   arg1 = (Dali::Rect< int > *)jarg1;
45954   arg2 = (int)jarg2;
45955   if (arg1) (arg1)->x = arg2;
45956 }
45957
45958
45959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
45960   int jresult ;
45961   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45962   int result;
45963
45964   arg1 = (Dali::Rect< int > *)jarg1;
45965   result = (int) ((arg1)->x);
45966   jresult = result;
45967   return jresult;
45968 }
45969
45970
45971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
45972   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45973   int arg2 ;
45974
45975   arg1 = (Dali::Rect< int > *)jarg1;
45976   arg2 = (int)jarg2;
45977   if (arg1) (arg1)->left = arg2;
45978 }
45979
45980
45981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
45982   int jresult ;
45983   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45984   int result;
45985
45986   arg1 = (Dali::Rect< int > *)jarg1;
45987   result = (int) ((arg1)->left);
45988   jresult = result;
45989   return jresult;
45990 }
45991
45992
45993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
45994   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45995   int arg2 ;
45996
45997   arg1 = (Dali::Rect< int > *)jarg1;
45998   arg2 = (int)jarg2;
45999   if (arg1) (arg1)->y = arg2;
46000 }
46001
46002
46003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
46004   int jresult ;
46005   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46006   int result;
46007
46008   arg1 = (Dali::Rect< int > *)jarg1;
46009   result = (int) ((arg1)->y);
46010   jresult = result;
46011   return jresult;
46012 }
46013
46014
46015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
46016   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46017   int arg2 ;
46018
46019   arg1 = (Dali::Rect< int > *)jarg1;
46020   arg2 = (int)jarg2;
46021   if (arg1) (arg1)->right = arg2;
46022 }
46023
46024
46025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
46026   int jresult ;
46027   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46028   int result;
46029
46030   arg1 = (Dali::Rect< int > *)jarg1;
46031   result = (int) ((arg1)->right);
46032   jresult = result;
46033   return jresult;
46034 }
46035
46036
46037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
46038   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46039   int arg2 ;
46040
46041   arg1 = (Dali::Rect< int > *)jarg1;
46042   arg2 = (int)jarg2;
46043   if (arg1) (arg1)->width = arg2;
46044 }
46045
46046
46047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
46048   int jresult ;
46049   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46050   int result;
46051
46052   arg1 = (Dali::Rect< int > *)jarg1;
46053   result = (int) ((arg1)->width);
46054   jresult = result;
46055   return jresult;
46056 }
46057
46058
46059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
46060   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46061   int arg2 ;
46062
46063   arg1 = (Dali::Rect< int > *)jarg1;
46064   arg2 = (int)jarg2;
46065   if (arg1) (arg1)->bottom = arg2;
46066 }
46067
46068
46069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
46070   int jresult ;
46071   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46072   int result;
46073
46074   arg1 = (Dali::Rect< int > *)jarg1;
46075   result = (int) ((arg1)->bottom);
46076   jresult = result;
46077   return jresult;
46078 }
46079
46080
46081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
46082   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46083   int arg2 ;
46084
46085   arg1 = (Dali::Rect< int > *)jarg1;
46086   arg2 = (int)jarg2;
46087   if (arg1) (arg1)->height = arg2;
46088 }
46089
46090
46091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
46092   int jresult ;
46093   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46094   int result;
46095
46096   arg1 = (Dali::Rect< int > *)jarg1;
46097   result = (int) ((arg1)->height);
46098   jresult = result;
46099   return jresult;
46100 }
46101
46102
46103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
46104   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46105   int arg2 ;
46106
46107   arg1 = (Dali::Rect< int > *)jarg1;
46108   arg2 = (int)jarg2;
46109   if (arg1) (arg1)->top = arg2;
46110 }
46111
46112
46113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
46114   int jresult ;
46115   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46116   int result;
46117
46118   arg1 = (Dali::Rect< int > *)jarg1;
46119   result = (int) ((arg1)->top);
46120   jresult = result;
46121   return jresult;
46122 }
46123
46124
46125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
46126   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46127
46128   arg1 = (Dali::Rect< int > *)jarg1;
46129   {
46130     try {
46131       delete arg1;
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_new_PaddingType__SWIG_0() {
46150   void * jresult ;
46151   Dali::Rect< float > *result = 0 ;
46152
46153   {
46154     try {
46155       result = (Dali::Rect< float > *)new Dali::Rect< float >();
46156     } catch (std::out_of_range& e) {
46157       {
46158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46159       };
46160     } catch (std::exception& e) {
46161       {
46162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46163       };
46164     } catch (...) {
46165       {
46166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46167       };
46168     }
46169   }
46170   jresult = (void *)result;
46171   return jresult;
46172 }
46173
46174
46175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
46176   void * jresult ;
46177   float arg1 ;
46178   float arg2 ;
46179   float arg3 ;
46180   float arg4 ;
46181   Dali::Rect< float > *result = 0 ;
46182
46183   arg1 = (float)jarg1;
46184   arg2 = (float)jarg2;
46185   arg3 = (float)jarg3;
46186   arg4 = (float)jarg4;
46187   {
46188     try {
46189       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
46190     } catch (std::out_of_range& e) {
46191       {
46192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46193       };
46194     } catch (std::exception& e) {
46195       {
46196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46197       };
46198     } catch (...) {
46199       {
46200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46201       };
46202     }
46203   }
46204   jresult = (void *)result;
46205   return jresult;
46206 }
46207
46208
46209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
46210   void * jresult ;
46211   Dali::Rect< float > *arg1 = 0 ;
46212   Dali::Rect< float > *result = 0 ;
46213
46214   arg1 = (Dali::Rect< float > *)jarg1;
46215   if (!arg1) {
46216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46217     return 0;
46218   }
46219   {
46220     try {
46221       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
46222     } catch (std::out_of_range& e) {
46223       {
46224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46225       };
46226     } catch (std::exception& e) {
46227       {
46228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46229       };
46230     } catch (...) {
46231       {
46232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46233       };
46234     }
46235   }
46236   jresult = (void *)result;
46237   return jresult;
46238 }
46239
46240
46241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
46242   void * jresult ;
46243   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46244   Dali::Rect< float > *arg2 = 0 ;
46245   Dali::Rect< float > *result = 0 ;
46246
46247   arg1 = (Dali::Rect< float > *)jarg1;
46248   arg2 = (Dali::Rect< float > *)jarg2;
46249   if (!arg2) {
46250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46251     return 0;
46252   }
46253   {
46254     try {
46255       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
46256     } catch (std::out_of_range& e) {
46257       {
46258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46259       };
46260     } catch (std::exception& e) {
46261       {
46262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46263       };
46264     } catch (...) {
46265       {
46266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46267       };
46268     }
46269   }
46270   jresult = (void *)result;
46271   return jresult;
46272 }
46273
46274
46275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
46276   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46277   float arg2 ;
46278   float arg3 ;
46279   float arg4 ;
46280   float arg5 ;
46281
46282   arg1 = (Dali::Rect< float > *)jarg1;
46283   arg2 = (float)jarg2;
46284   arg3 = (float)jarg3;
46285   arg4 = (float)jarg4;
46286   arg5 = (float)jarg5;
46287   {
46288     try {
46289       (arg1)->Set(arg2,arg3,arg4,arg5);
46290     } catch (std::out_of_range& e) {
46291       {
46292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46293       };
46294     } catch (std::exception& e) {
46295       {
46296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46297       };
46298     } catch (...) {
46299       {
46300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46301       };
46302     }
46303   }
46304 }
46305
46306
46307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_x_set(void * jarg1, float jarg2) {
46308   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46309   float arg2 ;
46310
46311   arg1 = (Dali::Rect< float > *)jarg1;
46312   arg2 = (float)jarg2;
46313   if (arg1) (arg1)->x = arg2;
46314 }
46315
46316
46317 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_x_get(void * jarg1) {
46318   float jresult ;
46319   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46320   float result;
46321
46322   arg1 = (Dali::Rect< float > *)jarg1;
46323   result = (float) ((arg1)->x);
46324   jresult = result;
46325   return jresult;
46326 }
46327
46328
46329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
46330   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46331   float arg2 ;
46332
46333   arg1 = (Dali::Rect< float > *)jarg1;
46334   arg2 = (float)jarg2;
46335   if (arg1) (arg1)->left = arg2;
46336 }
46337
46338
46339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
46340   float jresult ;
46341   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46342   float result;
46343
46344   arg1 = (Dali::Rect< float > *)jarg1;
46345   result = (float) ((arg1)->left);
46346   jresult = result;
46347   return jresult;
46348 }
46349
46350
46351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_y_set(void * jarg1, float jarg2) {
46352   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46353   float arg2 ;
46354
46355   arg1 = (Dali::Rect< float > *)jarg1;
46356   arg2 = (float)jarg2;
46357   if (arg1) (arg1)->y = arg2;
46358 }
46359
46360
46361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_y_get(void * jarg1) {
46362   float jresult ;
46363   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46364   float result;
46365
46366   arg1 = (Dali::Rect< float > *)jarg1;
46367   result = (float) ((arg1)->y);
46368   jresult = result;
46369   return jresult;
46370 }
46371
46372
46373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
46374   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46375   float arg2 ;
46376
46377   arg1 = (Dali::Rect< float > *)jarg1;
46378   arg2 = (float)jarg2;
46379   if (arg1) (arg1)->right = arg2;
46380 }
46381
46382
46383 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
46384   float jresult ;
46385   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46386   float result;
46387
46388   arg1 = (Dali::Rect< float > *)jarg1;
46389   result = (float) ((arg1)->right);
46390   jresult = result;
46391   return jresult;
46392 }
46393
46394
46395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_width_set(void * jarg1, float jarg2) {
46396   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46397   float arg2 ;
46398
46399   arg1 = (Dali::Rect< float > *)jarg1;
46400   arg2 = (float)jarg2;
46401   if (arg1) (arg1)->width = arg2;
46402 }
46403
46404
46405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_width_get(void * jarg1) {
46406   float jresult ;
46407   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46408   float result;
46409
46410   arg1 = (Dali::Rect< float > *)jarg1;
46411   result = (float) ((arg1)->width);
46412   jresult = result;
46413   return jresult;
46414 }
46415
46416
46417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
46418   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46419   float arg2 ;
46420
46421   arg1 = (Dali::Rect< float > *)jarg1;
46422   arg2 = (float)jarg2;
46423   if (arg1) (arg1)->bottom = arg2;
46424 }
46425
46426
46427 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
46428   float jresult ;
46429   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46430   float result;
46431
46432   arg1 = (Dali::Rect< float > *)jarg1;
46433   result = (float) ((arg1)->bottom);
46434   jresult = result;
46435   return jresult;
46436 }
46437
46438
46439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_height_set(void * jarg1, float jarg2) {
46440   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46441   float arg2 ;
46442
46443   arg1 = (Dali::Rect< float > *)jarg1;
46444   arg2 = (float)jarg2;
46445   if (arg1) (arg1)->height = arg2;
46446 }
46447
46448
46449 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_height_get(void * jarg1) {
46450   float jresult ;
46451   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46452   float result;
46453
46454   arg1 = (Dali::Rect< float > *)jarg1;
46455   result = (float) ((arg1)->height);
46456   jresult = result;
46457   return jresult;
46458 }
46459
46460
46461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
46462   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46463   float arg2 ;
46464
46465   arg1 = (Dali::Rect< float > *)jarg1;
46466   arg2 = (float)jarg2;
46467   if (arg1) (arg1)->top = arg2;
46468 }
46469
46470
46471 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
46472   float jresult ;
46473   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46474   float result;
46475
46476   arg1 = (Dali::Rect< float > *)jarg1;
46477   result = (float) ((arg1)->top);
46478   jresult = result;
46479   return jresult;
46480 }
46481
46482
46483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
46484   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46485
46486   arg1 = (Dali::Rect< float > *)jarg1;
46487   {
46488     try {
46489       delete arg1;
46490     } catch (std::out_of_range& e) {
46491       {
46492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46493       };
46494     } catch (std::exception& e) {
46495       {
46496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46497       };
46498     } catch (...) {
46499       {
46500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46501       };
46502     }
46503   }
46504 }
46505
46506
46507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
46508   int jresult ;
46509   int result;
46510
46511   result = (int)Dali::Vector< int >::BaseType;
46512   jresult = (int)result;
46513   return jresult;
46514 }
46515
46516
46517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
46518   void * jresult ;
46519   Dali::Vector< int > *result = 0 ;
46520
46521   {
46522     try {
46523       result = (Dali::Vector< int > *)new Dali::Vector< int >();
46524     } catch (std::out_of_range& e) {
46525       {
46526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46527       };
46528     } catch (std::exception& e) {
46529       {
46530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46531       };
46532     } catch (...) {
46533       {
46534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46535       };
46536     }
46537   }
46538   jresult = (void *)result;
46539   return jresult;
46540 }
46541
46542
46543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
46544   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46545
46546   arg1 = (Dali::Vector< int > *)jarg1;
46547   {
46548     try {
46549       delete arg1;
46550     } catch (std::out_of_range& e) {
46551       {
46552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46553       };
46554     } catch (std::exception& e) {
46555       {
46556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46557       };
46558     } catch (...) {
46559       {
46560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46561       };
46562     }
46563   }
46564 }
46565
46566
46567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
46568   void * jresult ;
46569   Dali::Vector< int > *arg1 = 0 ;
46570   Dali::Vector< int > *result = 0 ;
46571
46572   arg1 = (Dali::Vector< int > *)jarg1;
46573   if (!arg1) {
46574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46575     return 0;
46576   }
46577   {
46578     try {
46579       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
46580     } catch (std::out_of_range& e) {
46581       {
46582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46583       };
46584     } catch (std::exception& e) {
46585       {
46586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46587       };
46588     } catch (...) {
46589       {
46590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46591       };
46592     }
46593   }
46594   jresult = (void *)result;
46595   return jresult;
46596 }
46597
46598
46599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
46600   void * jresult ;
46601   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46602   Dali::Vector< int > *arg2 = 0 ;
46603   Dali::Vector< int > *result = 0 ;
46604
46605   arg1 = (Dali::Vector< int > *)jarg1;
46606   arg2 = (Dali::Vector< int > *)jarg2;
46607   if (!arg2) {
46608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46609     return 0;
46610   }
46611   {
46612     try {
46613       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
46614     } catch (std::out_of_range& e) {
46615       {
46616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46617       };
46618     } catch (std::exception& e) {
46619       {
46620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46621       };
46622     } catch (...) {
46623       {
46624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46625       };
46626     }
46627   }
46628   jresult = (void *)result;
46629   return jresult;
46630 }
46631
46632
46633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
46634   void * jresult ;
46635   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46636   Dali::Vector< int >::Iterator result;
46637
46638   arg1 = (Dali::Vector< int > *)jarg1;
46639   {
46640     try {
46641       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
46642     } catch (std::out_of_range& e) {
46643       {
46644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46645       };
46646     } catch (std::exception& e) {
46647       {
46648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46649       };
46650     } catch (...) {
46651       {
46652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46653       };
46654     }
46655   }
46656   jresult = (void *)result;
46657   return jresult;
46658 }
46659
46660
46661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
46662   void * jresult ;
46663   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46664   Dali::Vector< int >::Iterator result;
46665
46666   arg1 = (Dali::Vector< int > *)jarg1;
46667   {
46668     try {
46669       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
46670     } catch (std::out_of_range& e) {
46671       {
46672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46673       };
46674     } catch (std::exception& e) {
46675       {
46676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46677       };
46678     } catch (...) {
46679       {
46680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46681       };
46682     }
46683   }
46684   jresult = (void *)result;
46685   return jresult;
46686 }
46687
46688
46689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46690   void * jresult ;
46691   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46692   Dali::Vector< int >::SizeType arg2 ;
46693   Dali::Vector< int >::ItemType *result = 0 ;
46694
46695   arg1 = (Dali::Vector< int > *)jarg1;
46696   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46697   {
46698     try {
46699       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
46700     } catch (std::out_of_range& e) {
46701       {
46702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46703       };
46704     } catch (std::exception& e) {
46705       {
46706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46707       };
46708     } catch (...) {
46709       {
46710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46711       };
46712     }
46713   }
46714   jresult = (void *)result;
46715   return jresult;
46716 }
46717
46718
46719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
46720   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46721   Dali::Vector< int >::ItemType *arg2 = 0 ;
46722   Dali::Vector< int >::ItemType temp2 ;
46723
46724   arg1 = (Dali::Vector< int > *)jarg1;
46725   temp2 = (Dali::Vector< int >::ItemType)jarg2;
46726   arg2 = &temp2;
46727   {
46728     try {
46729       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
46730     } catch (std::out_of_range& e) {
46731       {
46732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46733       };
46734     } catch (std::exception& e) {
46735       {
46736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46737       };
46738     } catch (...) {
46739       {
46740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46741       };
46742     }
46743   }
46744 }
46745
46746
46747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
46748   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46749   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46750   Dali::Vector< int >::ItemType *arg3 = 0 ;
46751   Dali::Vector< int >::ItemType temp3 ;
46752
46753   arg1 = (Dali::Vector< int > *)jarg1;
46754   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46755   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46756   arg3 = &temp3;
46757   {
46758     try {
46759       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46760     } catch (std::out_of_range& e) {
46761       {
46762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46763       };
46764     } catch (std::exception& e) {
46765       {
46766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46767       };
46768     } catch (...) {
46769       {
46770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46771       };
46772     }
46773   }
46774 }
46775
46776
46777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46778   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46779   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46780   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46781   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
46782
46783   arg1 = (Dali::Vector< int > *)jarg1;
46784   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46785   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46786   arg4 = (Dali::Vector< int >::Iterator)jarg4;
46787   {
46788     try {
46789       (arg1)->Insert(arg2,arg3,arg4);
46790     } catch (std::out_of_range& e) {
46791       {
46792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46793       };
46794     } catch (std::exception& e) {
46795       {
46796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46797       };
46798     } catch (...) {
46799       {
46800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46801       };
46802     }
46803   }
46804 }
46805
46806
46807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
46808   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46809   Dali::Vector< int >::SizeType arg2 ;
46810
46811   arg1 = (Dali::Vector< int > *)jarg1;
46812   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46813   {
46814     try {
46815       (arg1)->Reserve(arg2);
46816     } catch (std::out_of_range& e) {
46817       {
46818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46819       };
46820     } catch (std::exception& e) {
46821       {
46822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46823       };
46824     } catch (...) {
46825       {
46826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46827       };
46828     }
46829   }
46830 }
46831
46832
46833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46834   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46835   Dali::Vector< int >::SizeType arg2 ;
46836
46837   arg1 = (Dali::Vector< int > *)jarg1;
46838   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46839   {
46840     try {
46841       (arg1)->Resize(arg2);
46842     } catch (std::out_of_range& e) {
46843       {
46844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46845       };
46846     } catch (std::exception& e) {
46847       {
46848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46849       };
46850     } catch (...) {
46851       {
46852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46853       };
46854     }
46855   }
46856 }
46857
46858
46859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
46860   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46861   Dali::Vector< int >::SizeType arg2 ;
46862   Dali::Vector< int >::ItemType *arg3 = 0 ;
46863   Dali::Vector< int >::ItemType temp3 ;
46864
46865   arg1 = (Dali::Vector< int > *)jarg1;
46866   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46867   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46868   arg3 = &temp3;
46869   {
46870     try {
46871       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46872     } catch (std::out_of_range& e) {
46873       {
46874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46875       };
46876     } catch (std::exception& e) {
46877       {
46878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46879       };
46880     } catch (...) {
46881       {
46882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46883       };
46884     }
46885   }
46886 }
46887
46888
46889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
46890   void * jresult ;
46891   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46892   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46893   Dali::Vector< int >::Iterator result;
46894
46895   arg1 = (Dali::Vector< int > *)jarg1;
46896   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46897   {
46898     try {
46899       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
46900     } catch (std::out_of_range& e) {
46901       {
46902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46903       };
46904     } catch (std::exception& e) {
46905       {
46906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46907       };
46908     } catch (...) {
46909       {
46910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46911       };
46912     }
46913   }
46914   jresult = (void *)result;
46915   return jresult;
46916 }
46917
46918
46919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46920   void * jresult ;
46921   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46922   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46923   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46924   Dali::Vector< int >::Iterator result;
46925
46926   arg1 = (Dali::Vector< int > *)jarg1;
46927   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46928   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46929   {
46930     try {
46931       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
46932     } catch (std::out_of_range& e) {
46933       {
46934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46935       };
46936     } catch (std::exception& e) {
46937       {
46938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46939       };
46940     } catch (...) {
46941       {
46942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46943       };
46944     }
46945   }
46946   jresult = (void *)result;
46947   return jresult;
46948 }
46949
46950
46951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
46952   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46953   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46954
46955   arg1 = (Dali::Vector< int > *)jarg1;
46956   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46957   {
46958     try {
46959       (arg1)->Remove(arg2);
46960     } catch (std::out_of_range& e) {
46961       {
46962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46963       };
46964     } catch (std::exception& e) {
46965       {
46966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46967       };
46968     } catch (...) {
46969       {
46970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46971       };
46972     }
46973   }
46974 }
46975
46976
46977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
46978   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46979   Dali::Vector< int > *arg2 = 0 ;
46980
46981   arg1 = (Dali::Vector< int > *)jarg1;
46982   arg2 = (Dali::Vector< int > *)jarg2;
46983   if (!arg2) {
46984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
46985     return ;
46986   }
46987   {
46988     try {
46989       (arg1)->Swap(*arg2);
46990     } catch (std::out_of_range& e) {
46991       {
46992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46993       };
46994     } catch (std::exception& e) {
46995       {
46996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46997       };
46998     } catch (...) {
46999       {
47000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47001       };
47002     }
47003   }
47004 }
47005
47006
47007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
47008   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47009
47010   arg1 = (Dali::Vector< int > *)jarg1;
47011   {
47012     try {
47013       (arg1)->Clear();
47014     } catch (std::out_of_range& e) {
47015       {
47016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47017       };
47018     } catch (std::exception& e) {
47019       {
47020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47021       };
47022     } catch (...) {
47023       {
47024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47025       };
47026     }
47027   }
47028 }
47029
47030
47031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
47032   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47033
47034   arg1 = (Dali::Vector< int > *)jarg1;
47035   {
47036     try {
47037       (arg1)->Release();
47038     } catch (std::out_of_range& e) {
47039       {
47040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47041       };
47042     } catch (std::exception& e) {
47043       {
47044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47045       };
47046     } catch (...) {
47047       {
47048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47049       };
47050     }
47051   }
47052 }
47053
47054
47055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
47056   int jresult ;
47057   int result;
47058
47059   result = (int)Dali::Vector< float >::BaseType;
47060   jresult = (int)result;
47061   return jresult;
47062 }
47063
47064
47065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
47066   void * jresult ;
47067   Dali::Vector< float > *result = 0 ;
47068
47069   {
47070     try {
47071       result = (Dali::Vector< float > *)new Dali::Vector< float >();
47072     } catch (std::out_of_range& e) {
47073       {
47074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47075       };
47076     } catch (std::exception& e) {
47077       {
47078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47079       };
47080     } catch (...) {
47081       {
47082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47083       };
47084     }
47085   }
47086   jresult = (void *)result;
47087   return jresult;
47088 }
47089
47090
47091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
47092   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47093
47094   arg1 = (Dali::Vector< float > *)jarg1;
47095   {
47096     try {
47097       delete arg1;
47098     } catch (std::out_of_range& e) {
47099       {
47100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47101       };
47102     } catch (std::exception& e) {
47103       {
47104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47105       };
47106     } catch (...) {
47107       {
47108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47109       };
47110     }
47111   }
47112 }
47113
47114
47115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
47116   void * jresult ;
47117   Dali::Vector< float > *arg1 = 0 ;
47118   Dali::Vector< float > *result = 0 ;
47119
47120   arg1 = (Dali::Vector< float > *)jarg1;
47121   if (!arg1) {
47122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47123     return 0;
47124   }
47125   {
47126     try {
47127       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
47128     } catch (std::out_of_range& e) {
47129       {
47130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47131       };
47132     } catch (std::exception& e) {
47133       {
47134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47135       };
47136     } catch (...) {
47137       {
47138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47139       };
47140     }
47141   }
47142   jresult = (void *)result;
47143   return jresult;
47144 }
47145
47146
47147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
47148   void * jresult ;
47149   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47150   Dali::Vector< float > *arg2 = 0 ;
47151   Dali::Vector< float > *result = 0 ;
47152
47153   arg1 = (Dali::Vector< float > *)jarg1;
47154   arg2 = (Dali::Vector< float > *)jarg2;
47155   if (!arg2) {
47156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47157     return 0;
47158   }
47159   {
47160     try {
47161       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
47162     } catch (std::out_of_range& e) {
47163       {
47164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47165       };
47166     } catch (std::exception& e) {
47167       {
47168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47169       };
47170     } catch (...) {
47171       {
47172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47173       };
47174     }
47175   }
47176   jresult = (void *)result;
47177   return jresult;
47178 }
47179
47180
47181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
47182   void * jresult ;
47183   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47184   Dali::Vector< float >::Iterator result;
47185
47186   arg1 = (Dali::Vector< float > *)jarg1;
47187   {
47188     try {
47189       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
47190     } catch (std::out_of_range& e) {
47191       {
47192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47193       };
47194     } catch (std::exception& e) {
47195       {
47196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47197       };
47198     } catch (...) {
47199       {
47200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47201       };
47202     }
47203   }
47204   jresult = (void *)result;
47205   return jresult;
47206 }
47207
47208
47209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
47210   void * jresult ;
47211   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47212   Dali::Vector< float >::Iterator result;
47213
47214   arg1 = (Dali::Vector< float > *)jarg1;
47215   {
47216     try {
47217       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
47218     } catch (std::out_of_range& e) {
47219       {
47220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47221       };
47222     } catch (std::exception& e) {
47223       {
47224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47225       };
47226     } catch (...) {
47227       {
47228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47229       };
47230     }
47231   }
47232   jresult = (void *)result;
47233   return jresult;
47234 }
47235
47236
47237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47238   void * jresult ;
47239   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47240   Dali::Vector< float >::SizeType arg2 ;
47241   Dali::Vector< float >::ItemType *result = 0 ;
47242
47243   arg1 = (Dali::Vector< float > *)jarg1;
47244   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47245   {
47246     try {
47247       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
47248     } catch (std::out_of_range& e) {
47249       {
47250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47251       };
47252     } catch (std::exception& e) {
47253       {
47254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47255       };
47256     } catch (...) {
47257       {
47258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47259       };
47260     }
47261   }
47262   jresult = (void *)result;
47263   return jresult;
47264 }
47265
47266
47267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
47268   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47269   Dali::Vector< float >::ItemType *arg2 = 0 ;
47270   Dali::Vector< float >::ItemType temp2 ;
47271
47272   arg1 = (Dali::Vector< float > *)jarg1;
47273   temp2 = (Dali::Vector< float >::ItemType)jarg2;
47274   arg2 = &temp2;
47275   {
47276     try {
47277       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
47278     } catch (std::out_of_range& e) {
47279       {
47280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47281       };
47282     } catch (std::exception& e) {
47283       {
47284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47285       };
47286     } catch (...) {
47287       {
47288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47289       };
47290     }
47291   }
47292 }
47293
47294
47295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
47296   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47297   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47298   Dali::Vector< float >::ItemType *arg3 = 0 ;
47299   Dali::Vector< float >::ItemType temp3 ;
47300
47301   arg1 = (Dali::Vector< float > *)jarg1;
47302   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47303   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47304   arg3 = &temp3;
47305   {
47306     try {
47307       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47308     } catch (std::out_of_range& e) {
47309       {
47310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47311       };
47312     } catch (std::exception& e) {
47313       {
47314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47315       };
47316     } catch (...) {
47317       {
47318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47319       };
47320     }
47321   }
47322 }
47323
47324
47325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47326   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47327   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47328   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47329   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
47330
47331   arg1 = (Dali::Vector< float > *)jarg1;
47332   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47333   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47334   arg4 = (Dali::Vector< float >::Iterator)jarg4;
47335   {
47336     try {
47337       (arg1)->Insert(arg2,arg3,arg4);
47338     } catch (std::out_of_range& e) {
47339       {
47340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47341       };
47342     } catch (std::exception& e) {
47343       {
47344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47345       };
47346     } catch (...) {
47347       {
47348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47349       };
47350     }
47351   }
47352 }
47353
47354
47355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
47356   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47357   Dali::Vector< float >::SizeType arg2 ;
47358
47359   arg1 = (Dali::Vector< float > *)jarg1;
47360   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47361   {
47362     try {
47363       (arg1)->Reserve(arg2);
47364     } catch (std::out_of_range& e) {
47365       {
47366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47367       };
47368     } catch (std::exception& e) {
47369       {
47370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47371       };
47372     } catch (...) {
47373       {
47374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47375       };
47376     }
47377   }
47378 }
47379
47380
47381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47382   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47383   Dali::Vector< float >::SizeType arg2 ;
47384
47385   arg1 = (Dali::Vector< float > *)jarg1;
47386   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47387   {
47388     try {
47389       (arg1)->Resize(arg2);
47390     } catch (std::out_of_range& e) {
47391       {
47392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47393       };
47394     } catch (std::exception& e) {
47395       {
47396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47397       };
47398     } catch (...) {
47399       {
47400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47401       };
47402     }
47403   }
47404 }
47405
47406
47407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
47408   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47409   Dali::Vector< float >::SizeType arg2 ;
47410   Dali::Vector< float >::ItemType *arg3 = 0 ;
47411   Dali::Vector< float >::ItemType temp3 ;
47412
47413   arg1 = (Dali::Vector< float > *)jarg1;
47414   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47415   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47416   arg3 = &temp3;
47417   {
47418     try {
47419       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47420     } catch (std::out_of_range& e) {
47421       {
47422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47423       };
47424     } catch (std::exception& e) {
47425       {
47426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47427       };
47428     } catch (...) {
47429       {
47430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47431       };
47432     }
47433   }
47434 }
47435
47436
47437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
47438   void * jresult ;
47439   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47440   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47441   Dali::Vector< float >::Iterator result;
47442
47443   arg1 = (Dali::Vector< float > *)jarg1;
47444   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47445   {
47446     try {
47447       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
47448     } catch (std::out_of_range& e) {
47449       {
47450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47451       };
47452     } catch (std::exception& e) {
47453       {
47454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47455       };
47456     } catch (...) {
47457       {
47458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47459       };
47460     }
47461   }
47462   jresult = (void *)result;
47463   return jresult;
47464 }
47465
47466
47467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
47468   void * jresult ;
47469   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47470   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47471   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47472   Dali::Vector< float >::Iterator result;
47473
47474   arg1 = (Dali::Vector< float > *)jarg1;
47475   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47476   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47477   {
47478     try {
47479       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
47480     } catch (std::out_of_range& e) {
47481       {
47482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47483       };
47484     } catch (std::exception& e) {
47485       {
47486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47487       };
47488     } catch (...) {
47489       {
47490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47491       };
47492     }
47493   }
47494   jresult = (void *)result;
47495   return jresult;
47496 }
47497
47498
47499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
47500   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47501   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47502
47503   arg1 = (Dali::Vector< float > *)jarg1;
47504   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47505   {
47506     try {
47507       (arg1)->Remove(arg2);
47508     } catch (std::out_of_range& e) {
47509       {
47510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47511       };
47512     } catch (std::exception& e) {
47513       {
47514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47515       };
47516     } catch (...) {
47517       {
47518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47519       };
47520     }
47521   }
47522 }
47523
47524
47525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
47526   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47527   Dali::Vector< float > *arg2 = 0 ;
47528
47529   arg1 = (Dali::Vector< float > *)jarg1;
47530   arg2 = (Dali::Vector< float > *)jarg2;
47531   if (!arg2) {
47532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
47533     return ;
47534   }
47535   {
47536     try {
47537       (arg1)->Swap(*arg2);
47538     } catch (std::out_of_range& e) {
47539       {
47540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47541       };
47542     } catch (std::exception& e) {
47543       {
47544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47545       };
47546     } catch (...) {
47547       {
47548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47549       };
47550     }
47551   }
47552 }
47553
47554
47555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
47556   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47557
47558   arg1 = (Dali::Vector< float > *)jarg1;
47559   {
47560     try {
47561       (arg1)->Clear();
47562     } catch (std::out_of_range& e) {
47563       {
47564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47565       };
47566     } catch (std::exception& e) {
47567       {
47568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47569       };
47570     } catch (...) {
47571       {
47572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47573       };
47574     }
47575   }
47576 }
47577
47578
47579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
47580   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47581
47582   arg1 = (Dali::Vector< float > *)jarg1;
47583   {
47584     try {
47585       (arg1)->Release();
47586     } catch (std::out_of_range& e) {
47587       {
47588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47589       };
47590     } catch (std::exception& e) {
47591       {
47592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47593       };
47594     } catch (...) {
47595       {
47596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47597       };
47598     }
47599   }
47600 }
47601
47602
47603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
47604   int jresult ;
47605   int result;
47606
47607   result = (int)Dali::Vector< unsigned char >::BaseType;
47608   jresult = (int)result;
47609   return jresult;
47610 }
47611
47612
47613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
47614   void * jresult ;
47615   Dali::Vector< unsigned char > *result = 0 ;
47616
47617   {
47618     try {
47619       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
47620     } catch (std::out_of_range& e) {
47621       {
47622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47623       };
47624     } catch (std::exception& e) {
47625       {
47626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47627       };
47628     } catch (...) {
47629       {
47630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47631       };
47632     }
47633   }
47634   jresult = (void *)result;
47635   return jresult;
47636 }
47637
47638
47639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
47640   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47641
47642   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47643   {
47644     try {
47645       delete arg1;
47646     } catch (std::out_of_range& e) {
47647       {
47648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47649       };
47650     } catch (std::exception& e) {
47651       {
47652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47653       };
47654     } catch (...) {
47655       {
47656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47657       };
47658     }
47659   }
47660 }
47661
47662
47663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
47664   void * jresult ;
47665   Dali::Vector< unsigned char > *arg1 = 0 ;
47666   Dali::Vector< unsigned char > *result = 0 ;
47667
47668   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47669   if (!arg1) {
47670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47671     return 0;
47672   }
47673   {
47674     try {
47675       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
47676     } catch (std::out_of_range& e) {
47677       {
47678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47679       };
47680     } catch (std::exception& e) {
47681       {
47682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47683       };
47684     } catch (...) {
47685       {
47686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47687       };
47688     }
47689   }
47690   jresult = (void *)result;
47691   return jresult;
47692 }
47693
47694
47695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
47696   void * jresult ;
47697   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47698   Dali::Vector< unsigned char > *arg2 = 0 ;
47699   Dali::Vector< unsigned char > *result = 0 ;
47700
47701   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47702   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47703   if (!arg2) {
47704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47705     return 0;
47706   }
47707   {
47708     try {
47709       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
47710     } catch (std::out_of_range& e) {
47711       {
47712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47713       };
47714     } catch (std::exception& e) {
47715       {
47716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47717       };
47718     } catch (...) {
47719       {
47720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47721       };
47722     }
47723   }
47724   jresult = (void *)result;
47725   return jresult;
47726 }
47727
47728
47729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
47730   void * jresult ;
47731   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47732   Dali::Vector< unsigned char >::Iterator result;
47733
47734   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47735   {
47736     try {
47737       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
47738     } catch (std::out_of_range& e) {
47739       {
47740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47741       };
47742     } catch (std::exception& e) {
47743       {
47744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47745       };
47746     } catch (...) {
47747       {
47748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47749       };
47750     }
47751   }
47752   jresult = (void *)result;
47753   return jresult;
47754 }
47755
47756
47757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
47758   void * jresult ;
47759   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47760   Dali::Vector< unsigned char >::Iterator result;
47761
47762   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47763   {
47764     try {
47765       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
47766     } catch (std::out_of_range& e) {
47767       {
47768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47769       };
47770     } catch (std::exception& e) {
47771       {
47772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47773       };
47774     } catch (...) {
47775       {
47776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47777       };
47778     }
47779   }
47780   jresult = (void *)result;
47781   return jresult;
47782 }
47783
47784
47785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47786   void * jresult ;
47787   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47788   Dali::Vector< unsigned char >::SizeType arg2 ;
47789   Dali::Vector< unsigned char >::ItemType *result = 0 ;
47790
47791   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47792   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47793   {
47794     try {
47795       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
47796     } catch (std::out_of_range& e) {
47797       {
47798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47799       };
47800     } catch (std::exception& e) {
47801       {
47802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47803       };
47804     } catch (...) {
47805       {
47806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47807       };
47808     }
47809   }
47810   jresult = (void *)result;
47811   return jresult;
47812 }
47813
47814
47815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
47816   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47817   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
47818   Dali::Vector< unsigned char >::ItemType temp2 ;
47819
47820   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47821   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
47822   arg2 = &temp2;
47823   {
47824     try {
47825       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
47826     } catch (std::out_of_range& e) {
47827       {
47828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47829       };
47830     } catch (std::exception& e) {
47831       {
47832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47833       };
47834     } catch (...) {
47835       {
47836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47837       };
47838     }
47839   }
47840 }
47841
47842
47843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
47844   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47845   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47846   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47847   Dali::Vector< unsigned char >::ItemType temp3 ;
47848
47849   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47850   arg2 = jarg2;
47851   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47852   arg3 = &temp3;
47853   {
47854     try {
47855       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47856     } catch (std::out_of_range& e) {
47857       {
47858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47859       };
47860     } catch (std::exception& e) {
47861       {
47862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47863       };
47864     } catch (...) {
47865       {
47866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47867       };
47868     }
47869   }
47870
47871
47872 }
47873
47874
47875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
47876   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47877   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47878   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47879   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47880
47881   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47882   arg2 = jarg2;
47883   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47884   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
47885   {
47886     try {
47887       (arg1)->Insert(arg2,arg3,arg4);
47888     } catch (std::out_of_range& e) {
47889       {
47890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47891       };
47892     } catch (std::exception& e) {
47893       {
47894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47895       };
47896     } catch (...) {
47897       {
47898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47899       };
47900     }
47901   }
47902
47903
47904 }
47905
47906
47907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
47908   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47909   Dali::Vector< unsigned char >::SizeType arg2 ;
47910
47911   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47912   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47913   {
47914     try {
47915       (arg1)->Reserve(arg2);
47916     } catch (std::out_of_range& e) {
47917       {
47918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47919       };
47920     } catch (std::exception& e) {
47921       {
47922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47923       };
47924     } catch (...) {
47925       {
47926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47927       };
47928     }
47929   }
47930 }
47931
47932
47933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47934   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47935   Dali::Vector< unsigned char >::SizeType arg2 ;
47936
47937   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47938   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47939   {
47940     try {
47941       (arg1)->Resize(arg2);
47942     } catch (std::out_of_range& e) {
47943       {
47944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47945       };
47946     } catch (std::exception& e) {
47947       {
47948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47949       };
47950     } catch (...) {
47951       {
47952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47953       };
47954     }
47955   }
47956 }
47957
47958
47959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
47960   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47961   Dali::Vector< unsigned char >::SizeType arg2 ;
47962   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47963   Dali::Vector< unsigned char >::ItemType temp3 ;
47964
47965   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47966   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47967   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47968   arg3 = &temp3;
47969   {
47970     try {
47971       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47972     } catch (std::out_of_range& e) {
47973       {
47974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47975       };
47976     } catch (std::exception& e) {
47977       {
47978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47979       };
47980     } catch (...) {
47981       {
47982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47983       };
47984     }
47985   }
47986 }
47987
47988
47989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
47990   void * jresult ;
47991   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47992   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47993   Dali::Vector< unsigned char >::Iterator result;
47994
47995   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47996   arg2 = jarg2;
47997   {
47998     try {
47999       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
48000     } catch (std::out_of_range& e) {
48001       {
48002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48003       };
48004     } catch (std::exception& e) {
48005       {
48006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48007       };
48008     } catch (...) {
48009       {
48010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48011       };
48012     }
48013   }
48014   jresult = (void *)result;
48015
48016
48017   return jresult;
48018 }
48019
48020
48021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
48022   void * jresult ;
48023   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48024   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48025   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48026   Dali::Vector< unsigned char >::Iterator result;
48027
48028   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48029   arg2 = jarg2;
48030   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
48031   {
48032     try {
48033       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
48034     } catch (std::out_of_range& e) {
48035       {
48036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48037       };
48038     } catch (std::exception& e) {
48039       {
48040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48041       };
48042     } catch (...) {
48043       {
48044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48045       };
48046     }
48047   }
48048   jresult = (void *)result;
48049
48050
48051   return jresult;
48052 }
48053
48054
48055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
48056   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48057   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48058
48059   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48060   arg2 = jarg2;
48061   {
48062     try {
48063       (arg1)->Remove(arg2);
48064     } catch (std::out_of_range& e) {
48065       {
48066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48067       };
48068     } catch (std::exception& e) {
48069       {
48070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48071       };
48072     } catch (...) {
48073       {
48074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48075       };
48076     }
48077   }
48078
48079
48080 }
48081
48082
48083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
48084   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48085   Dali::Vector< unsigned char > *arg2 = 0 ;
48086
48087   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48088   arg2 = (Dali::Vector< unsigned char > *)jarg2;
48089   if (!arg2) {
48090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
48091     return ;
48092   }
48093   {
48094     try {
48095       (arg1)->Swap(*arg2);
48096     } catch (std::out_of_range& e) {
48097       {
48098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48099       };
48100     } catch (std::exception& e) {
48101       {
48102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48103       };
48104     } catch (...) {
48105       {
48106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48107       };
48108     }
48109   }
48110 }
48111
48112
48113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
48114   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48115
48116   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48117   {
48118     try {
48119       (arg1)->Clear();
48120     } catch (std::out_of_range& e) {
48121       {
48122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48123       };
48124     } catch (std::exception& e) {
48125       {
48126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48127       };
48128     } catch (...) {
48129       {
48130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48131       };
48132     }
48133   }
48134 }
48135
48136
48137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
48138   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48139
48140   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48141   {
48142     try {
48143       (arg1)->Release();
48144     } catch (std::out_of_range& e) {
48145       {
48146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48147       };
48148     } catch (std::exception& e) {
48149       {
48150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48151       };
48152     } catch (...) {
48153       {
48154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48155       };
48156     }
48157   }
48158 }
48159
48160
48161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
48162   int jresult ;
48163   int result;
48164
48165   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
48166   jresult = (int)result;
48167   return jresult;
48168 }
48169
48170
48171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
48172   void * jresult ;
48173   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48174
48175   {
48176     try {
48177       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
48178     } catch (std::out_of_range& e) {
48179       {
48180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48181       };
48182     } catch (std::exception& e) {
48183       {
48184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48185       };
48186     } catch (...) {
48187       {
48188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48189       };
48190     }
48191   }
48192   jresult = (void *)result;
48193   return jresult;
48194 }
48195
48196
48197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
48198   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48199
48200   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48201   {
48202     try {
48203       delete arg1;
48204     } catch (std::out_of_range& e) {
48205       {
48206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48207       };
48208     } catch (std::exception& e) {
48209       {
48210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48211       };
48212     } catch (...) {
48213       {
48214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48215       };
48216     }
48217   }
48218 }
48219
48220
48221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
48222   void * jresult ;
48223   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
48224   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48225
48226   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48227   if (!arg1) {
48228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48229     return 0;
48230   }
48231   {
48232     try {
48233       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
48234     } catch (std::out_of_range& e) {
48235       {
48236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48237       };
48238     } catch (std::exception& e) {
48239       {
48240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48241       };
48242     } catch (...) {
48243       {
48244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48245       };
48246     }
48247   }
48248   jresult = (void *)result;
48249   return jresult;
48250 }
48251
48252
48253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
48254   void * jresult ;
48255   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48256   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48257   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48258
48259   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48260   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48261   if (!arg2) {
48262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48263     return 0;
48264   }
48265   {
48266     try {
48267       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
48268     } catch (std::out_of_range& e) {
48269       {
48270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48271       };
48272     } catch (std::exception& e) {
48273       {
48274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48275       };
48276     } catch (...) {
48277       {
48278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48279       };
48280     }
48281   }
48282   jresult = (void *)result;
48283   return jresult;
48284 }
48285
48286
48287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
48288   void * jresult ;
48289   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48290   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48291
48292   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48293   {
48294     try {
48295       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
48296     } catch (std::out_of_range& e) {
48297       {
48298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48299       };
48300     } catch (std::exception& e) {
48301       {
48302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48303       };
48304     } catch (...) {
48305       {
48306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48307       };
48308     }
48309   }
48310   jresult = (void *)result;
48311   return jresult;
48312 }
48313
48314
48315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
48316   void * jresult ;
48317   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48318   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48319
48320   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48321   {
48322     try {
48323       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
48324     } catch (std::out_of_range& e) {
48325       {
48326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48327       };
48328     } catch (std::exception& e) {
48329       {
48330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48331       };
48332     } catch (...) {
48333       {
48334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48335       };
48336     }
48337   }
48338   jresult = (void *)result;
48339   return jresult;
48340 }
48341
48342
48343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48344   void * jresult ;
48345   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48346   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48347   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
48348
48349   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48350   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48351   {
48352     try {
48353       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
48354     } catch (std::out_of_range& e) {
48355       {
48356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48357       };
48358     } catch (std::exception& e) {
48359       {
48360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48361       };
48362     } catch (...) {
48363       {
48364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48365       };
48366     }
48367   }
48368   jresult = (void *)result;
48369   return jresult;
48370 }
48371
48372
48373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
48374   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48375   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
48376
48377   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48378   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
48379   if (!arg2) {
48380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48381     return ;
48382   }
48383   {
48384     try {
48385       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
48386     } catch (std::out_of_range& e) {
48387       {
48388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48389       };
48390     } catch (std::exception& e) {
48391       {
48392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48393       };
48394     } catch (...) {
48395       {
48396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48397       };
48398     }
48399   }
48400 }
48401
48402
48403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
48404   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48405   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48406   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48407
48408   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48409   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48410   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48411   if (!arg3) {
48412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48413     return ;
48414   }
48415   {
48416     try {
48417       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48418     } catch (std::out_of_range& e) {
48419       {
48420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48421       };
48422     } catch (std::exception& e) {
48423       {
48424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48425       };
48426     } catch (...) {
48427       {
48428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48429       };
48430     }
48431   }
48432 }
48433
48434
48435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48436   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48437   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48438   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48439   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48440
48441   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48442   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48443   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48444   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
48445   {
48446     try {
48447       (arg1)->Insert(arg2,arg3,arg4);
48448     } catch (std::out_of_range& e) {
48449       {
48450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48451       };
48452     } catch (std::exception& e) {
48453       {
48454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48455       };
48456     } catch (...) {
48457       {
48458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48459       };
48460     }
48461   }
48462 }
48463
48464
48465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
48466   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48467   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48468
48469   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48470   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48471   {
48472     try {
48473       (arg1)->Reserve(arg2);
48474     } catch (std::out_of_range& e) {
48475       {
48476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48477       };
48478     } catch (std::exception& e) {
48479       {
48480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48481       };
48482     } catch (...) {
48483       {
48484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48485       };
48486     }
48487   }
48488 }
48489
48490
48491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48492   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48493   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48494
48495   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48496   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48497   {
48498     try {
48499       (arg1)->Resize(arg2);
48500     } catch (std::out_of_range& e) {
48501       {
48502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48503       };
48504     } catch (std::exception& e) {
48505       {
48506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48507       };
48508     } catch (...) {
48509       {
48510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48511       };
48512     }
48513   }
48514 }
48515
48516
48517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
48518   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48519   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48520   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48521
48522   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48523   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48524   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48525   if (!arg3) {
48526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48527     return ;
48528   }
48529   {
48530     try {
48531       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48532     } catch (std::out_of_range& e) {
48533       {
48534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48535       };
48536     } catch (std::exception& e) {
48537       {
48538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48539       };
48540     } catch (...) {
48541       {
48542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48543       };
48544     }
48545   }
48546 }
48547
48548
48549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
48550   void * jresult ;
48551   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48552   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48553   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48554
48555   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48556   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48557   {
48558     try {
48559       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
48560     } catch (std::out_of_range& e) {
48561       {
48562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48563       };
48564     } catch (std::exception& e) {
48565       {
48566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48567       };
48568     } catch (...) {
48569       {
48570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48571       };
48572     }
48573   }
48574   jresult = (void *)result;
48575   return jresult;
48576 }
48577
48578
48579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48580   void * jresult ;
48581   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48582   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48583   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48584   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48585
48586   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48587   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48588   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48589   {
48590     try {
48591       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
48592     } catch (std::out_of_range& e) {
48593       {
48594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48595       };
48596     } catch (std::exception& e) {
48597       {
48598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48599       };
48600     } catch (...) {
48601       {
48602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48603       };
48604     }
48605   }
48606   jresult = (void *)result;
48607   return jresult;
48608 }
48609
48610
48611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
48612   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48613   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48614
48615   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48616   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48617   {
48618     try {
48619       (arg1)->Remove(arg2);
48620     } catch (std::out_of_range& e) {
48621       {
48622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48623       };
48624     } catch (std::exception& e) {
48625       {
48626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48627       };
48628     } catch (...) {
48629       {
48630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48631       };
48632     }
48633   }
48634 }
48635
48636
48637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
48638   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48639   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48640
48641   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48642   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48643   if (!arg2) {
48644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
48645     return ;
48646   }
48647   {
48648     try {
48649       (arg1)->Swap(*arg2);
48650     } catch (std::out_of_range& e) {
48651       {
48652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48653       };
48654     } catch (std::exception& e) {
48655       {
48656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48657       };
48658     } catch (...) {
48659       {
48660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48661       };
48662     }
48663   }
48664 }
48665
48666
48667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
48668   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48669
48670   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48671   {
48672     try {
48673       (arg1)->Clear();
48674     } catch (std::out_of_range& e) {
48675       {
48676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48677       };
48678     } catch (std::exception& e) {
48679       {
48680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48681       };
48682     } catch (...) {
48683       {
48684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48685       };
48686     }
48687   }
48688 }
48689
48690
48691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
48692   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48693
48694   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48695   {
48696     try {
48697       (arg1)->Release();
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_new_VoidSignal() {
48716   void * jresult ;
48717   Dali::Signal< void () > *result = 0 ;
48718
48719   {
48720     try {
48721       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
48722     } catch (std::out_of_range& e) {
48723       {
48724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48725       };
48726     } catch (std::exception& e) {
48727       {
48728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48729       };
48730     } catch (...) {
48731       {
48732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48733       };
48734     }
48735   }
48736   jresult = (void *)result;
48737   return jresult;
48738 }
48739
48740
48741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
48742   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48743
48744   arg1 = (Dali::Signal< void () > *)jarg1;
48745   {
48746     try {
48747       delete arg1;
48748     } catch (std::out_of_range& e) {
48749       {
48750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48751       };
48752     } catch (std::exception& e) {
48753       {
48754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48755       };
48756     } catch (...) {
48757       {
48758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48759       };
48760     }
48761   }
48762 }
48763
48764
48765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
48766   unsigned int jresult ;
48767   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48768   bool result;
48769
48770   arg1 = (Dali::Signal< void () > *)jarg1;
48771   {
48772     try {
48773       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
48774     } catch (std::out_of_range& e) {
48775       {
48776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48777       };
48778     } catch (std::exception& e) {
48779       {
48780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48781       };
48782     } catch (...) {
48783       {
48784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48785       };
48786     }
48787   }
48788   jresult = result;
48789   return jresult;
48790 }
48791
48792
48793 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
48794   unsigned long jresult ;
48795   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48796   std::size_t result;
48797
48798   arg1 = (Dali::Signal< void () > *)jarg1;
48799   {
48800     try {
48801       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
48802     } catch (std::out_of_range& e) {
48803       {
48804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48805       };
48806     } catch (std::exception& e) {
48807       {
48808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48809       };
48810     } catch (...) {
48811       {
48812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48813       };
48814     }
48815   }
48816   jresult = (unsigned long)result;
48817   return jresult;
48818 }
48819
48820
48821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48822   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48823   void (*arg2)() = (void (*)()) 0 ;
48824
48825   arg1 = (Dali::Signal< void () > *)jarg1;
48826   arg2 = (void (*)())jarg2;
48827   {
48828     try {
48829       (arg1)->Connect(arg2);
48830     } catch (std::out_of_range& e) {
48831       {
48832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48833       };
48834     } catch (std::exception& e) {
48835       {
48836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48837       };
48838     } catch (...) {
48839       {
48840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48841       };
48842     }
48843   }
48844 }
48845
48846
48847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
48848   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48849   void (*arg2)() = (void (*)()) 0 ;
48850
48851   arg1 = (Dali::Signal< void () > *)jarg1;
48852   arg2 = (void (*)())jarg2;
48853   {
48854     try {
48855       (arg1)->Disconnect(arg2);
48856     } catch (std::out_of_range& e) {
48857       {
48858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48859       };
48860     } catch (std::exception& e) {
48861       {
48862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48863       };
48864     } catch (...) {
48865       {
48866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48867       };
48868     }
48869   }
48870 }
48871
48872
48873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48874   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48875   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48876   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48877
48878   arg1 = (Dali::Signal< void () > *)jarg1;
48879   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48880   arg3 = (Dali::FunctorDelegate *)jarg3;
48881   {
48882     try {
48883       (arg1)->Connect(arg2,arg3);
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_VoidSignal_Emit(void * jarg1) {
48902   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48903
48904   arg1 = (Dali::Signal< void () > *)jarg1;
48905   {
48906     try {
48907       (arg1)->Emit();
48908     } catch (std::out_of_range& e) {
48909       {
48910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48911       };
48912     } catch (std::exception& e) {
48913       {
48914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48915       };
48916     } catch (...) {
48917       {
48918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48919       };
48920     }
48921   }
48922 }
48923
48924
48925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
48926   unsigned int jresult ;
48927   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48928   bool result;
48929
48930   arg1 = (Dali::Signal< void (float) > *)jarg1;
48931   {
48932     try {
48933       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
48934     } catch (std::out_of_range& e) {
48935       {
48936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48937       };
48938     } catch (std::exception& e) {
48939       {
48940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48941       };
48942     } catch (...) {
48943       {
48944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48945       };
48946     }
48947   }
48948   jresult = result;
48949   return jresult;
48950 }
48951
48952
48953 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
48954   unsigned long jresult ;
48955   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48956   std::size_t result;
48957
48958   arg1 = (Dali::Signal< void (float) > *)jarg1;
48959   {
48960     try {
48961       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
48962     } catch (std::out_of_range& e) {
48963       {
48964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48965       };
48966     } catch (std::exception& e) {
48967       {
48968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48969       };
48970     } catch (...) {
48971       {
48972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48973       };
48974     }
48975   }
48976   jresult = (unsigned long)result;
48977   return jresult;
48978 }
48979
48980
48981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
48982   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48983   void (*arg2)(float) = (void (*)(float)) 0 ;
48984
48985   arg1 = (Dali::Signal< void (float) > *)jarg1;
48986   arg2 = (void (*)(float))jarg2;
48987   {
48988     try {
48989       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
48990     } catch (std::out_of_range& e) {
48991       {
48992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48993       };
48994     } catch (std::exception& e) {
48995       {
48996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48997       };
48998     } catch (...) {
48999       {
49000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49001       };
49002     }
49003   }
49004 }
49005
49006
49007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
49008   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49009   void (*arg2)(float) = (void (*)(float)) 0 ;
49010
49011   arg1 = (Dali::Signal< void (float) > *)jarg1;
49012   arg2 = (void (*)(float))jarg2;
49013   {
49014     try {
49015       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(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_FloatSignal_Emit(void * jarg1, float jarg2) {
49034   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49035   float arg2 ;
49036
49037   arg1 = (Dali::Signal< void (float) > *)jarg1;
49038   arg2 = (float)jarg2;
49039   {
49040     try {
49041       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(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_new_FloatSignal() {
49060   void * jresult ;
49061   Dali::Signal< void (float) > *result = 0 ;
49062
49063   {
49064     try {
49065       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
49066     } catch (std::out_of_range& e) {
49067       {
49068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49069       };
49070     } catch (std::exception& e) {
49071       {
49072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49073       };
49074     } catch (...) {
49075       {
49076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49077       };
49078     }
49079   }
49080   jresult = (void *)result;
49081   return jresult;
49082 }
49083
49084
49085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
49086   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49087
49088   arg1 = (Dali::Signal< void (float) > *)jarg1;
49089   {
49090     try {
49091       delete arg1;
49092     } catch (std::out_of_range& e) {
49093       {
49094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49095       };
49096     } catch (std::exception& e) {
49097       {
49098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49099       };
49100     } catch (...) {
49101       {
49102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49103       };
49104     }
49105   }
49106 }
49107
49108
49109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
49110   unsigned int jresult ;
49111   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49112   bool result;
49113
49114   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49115   {
49116     try {
49117       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49118     } catch (std::out_of_range& e) {
49119       {
49120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49121       };
49122     } catch (std::exception& e) {
49123       {
49124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49125       };
49126     } catch (...) {
49127       {
49128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49129       };
49130     }
49131   }
49132   jresult = result;
49133   return jresult;
49134 }
49135
49136
49137 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
49138   unsigned long jresult ;
49139   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49140   std::size_t result;
49141
49142   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49143   {
49144     try {
49145       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49146     } catch (std::out_of_range& e) {
49147       {
49148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49149       };
49150     } catch (std::exception& e) {
49151       {
49152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49153       };
49154     } catch (...) {
49155       {
49156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49157       };
49158     }
49159   }
49160   jresult = (unsigned long)result;
49161   return jresult;
49162 }
49163
49164
49165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
49166   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49167   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49168
49169   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49170   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49171   {
49172     try {
49173       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
49174     } catch (std::out_of_range& e) {
49175       {
49176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49177       };
49178     } catch (std::exception& e) {
49179       {
49180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49181       };
49182     } catch (...) {
49183       {
49184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49185       };
49186     }
49187   }
49188 }
49189
49190
49191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
49192   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49193   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49194
49195   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49196   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49197   {
49198     try {
49199       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
49200     } catch (std::out_of_range& e) {
49201       {
49202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49203       };
49204     } catch (std::exception& e) {
49205       {
49206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49207       };
49208     } catch (...) {
49209       {
49210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49211       };
49212     }
49213   }
49214 }
49215
49216
49217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
49218   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49219   Dali::BaseHandle arg2 ;
49220   Dali::BaseHandle *argp2 ;
49221
49222   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49223   argp2 = (Dali::BaseHandle *)jarg2;
49224   if (!argp2) {
49225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49226     return ;
49227   }
49228   arg2 = *argp2;
49229   {
49230     try {
49231       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(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_new_ObjectCreatedSignal() {
49250   void * jresult ;
49251   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
49252
49253   {
49254     try {
49255       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
49256     } catch (std::out_of_range& e) {
49257       {
49258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49259       };
49260     } catch (std::exception& e) {
49261       {
49262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49263       };
49264     } catch (...) {
49265       {
49266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49267       };
49268     }
49269   }
49270   jresult = (void *)result;
49271   return jresult;
49272 }
49273
49274
49275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
49276   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49277
49278   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49279   {
49280     try {
49281       delete arg1;
49282     } catch (std::out_of_range& e) {
49283       {
49284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49285       };
49286     } catch (std::exception& e) {
49287       {
49288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49289       };
49290     } catch (...) {
49291       {
49292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49293       };
49294     }
49295   }
49296 }
49297
49298
49299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
49300   unsigned int jresult ;
49301   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49302   bool result;
49303
49304   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49305   {
49306     try {
49307       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49308     } catch (std::out_of_range& e) {
49309       {
49310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49311       };
49312     } catch (std::exception& e) {
49313       {
49314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49315       };
49316     } catch (...) {
49317       {
49318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49319       };
49320     }
49321   }
49322   jresult = result;
49323   return jresult;
49324 }
49325
49326
49327 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
49328   unsigned long jresult ;
49329   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49330   std::size_t result;
49331
49332   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49333   {
49334     try {
49335       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49336     } catch (std::out_of_range& e) {
49337       {
49338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49339       };
49340     } catch (std::exception& e) {
49341       {
49342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49343       };
49344     } catch (...) {
49345       {
49346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49347       };
49348     }
49349   }
49350   jresult = (unsigned long)result;
49351   return jresult;
49352 }
49353
49354
49355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
49356   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49357   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49358
49359   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49360   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49361   {
49362     try {
49363       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
49364     } catch (std::out_of_range& e) {
49365       {
49366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49367       };
49368     } catch (std::exception& e) {
49369       {
49370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49371       };
49372     } catch (...) {
49373       {
49374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49375       };
49376     }
49377   }
49378 }
49379
49380
49381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
49382   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49383   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49384
49385   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49386   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49387   {
49388     try {
49389       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(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_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
49408   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49409   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
49410
49411   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49412   arg2 = (Dali::RefObject *)jarg2;
49413   {
49414     try {
49415       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)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_new_ObjectDestroyedSignal() {
49434   void * jresult ;
49435   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
49436
49437   {
49438     try {
49439       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
49440     } catch (std::out_of_range& e) {
49441       {
49442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49443       };
49444     } catch (std::exception& e) {
49445       {
49446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49447       };
49448     } catch (...) {
49449       {
49450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49451       };
49452     }
49453   }
49454   jresult = (void *)result;
49455   return jresult;
49456 }
49457
49458
49459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
49460   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49461
49462   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49463   {
49464     try {
49465       delete arg1;
49466     } catch (std::out_of_range& e) {
49467       {
49468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49469       };
49470     } catch (std::exception& e) {
49471       {
49472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49473       };
49474     } catch (...) {
49475       {
49476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49477       };
49478     }
49479   }
49480 }
49481
49482
49483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
49484   unsigned int jresult ;
49485   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49486   bool result;
49487
49488   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49489   {
49490     try {
49491       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49492     } catch (std::out_of_range& e) {
49493       {
49494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49495       };
49496     } catch (std::exception& e) {
49497       {
49498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49499       };
49500     } catch (...) {
49501       {
49502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49503       };
49504     }
49505   }
49506   jresult = result;
49507   return jresult;
49508 }
49509
49510
49511 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
49512   unsigned long jresult ;
49513   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49514   std::size_t result;
49515
49516   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49517   {
49518     try {
49519       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49520     } catch (std::out_of_range& e) {
49521       {
49522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49523       };
49524     } catch (std::exception& e) {
49525       {
49526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49527       };
49528     } catch (...) {
49529       {
49530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49531       };
49532     }
49533   }
49534   jresult = (unsigned long)result;
49535   return jresult;
49536 }
49537
49538
49539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
49540   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49541   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49542
49543   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49544   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49545   {
49546     try {
49547       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
49548     } catch (std::out_of_range& e) {
49549       {
49550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49551       };
49552     } catch (std::exception& e) {
49553       {
49554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49555       };
49556     } catch (...) {
49557       {
49558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49559       };
49560     }
49561   }
49562 }
49563
49564
49565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
49566   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49567   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49568
49569   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49570   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49571   {
49572     try {
49573       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
49574     } catch (std::out_of_range& e) {
49575       {
49576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49577       };
49578     } catch (std::exception& e) {
49579       {
49580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49581       };
49582     } catch (...) {
49583       {
49584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49585       };
49586     }
49587   }
49588 }
49589
49590
49591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
49592   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49593   Dali::PropertyNotification *arg2 = 0 ;
49594
49595   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49596   arg2 = (Dali::PropertyNotification *)jarg2;
49597   if (!arg2) {
49598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
49599     return ;
49600   }
49601   {
49602     try {
49603       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(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_new_PropertyNotifySignal() {
49622   void * jresult ;
49623   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
49624
49625   {
49626     try {
49627       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
49628     } catch (std::out_of_range& e) {
49629       {
49630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49631       };
49632     } catch (std::exception& e) {
49633       {
49634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49635       };
49636     } catch (...) {
49637       {
49638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49639       };
49640     }
49641   }
49642   jresult = (void *)result;
49643   return jresult;
49644 }
49645
49646
49647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
49648   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49649
49650   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49651   {
49652     try {
49653       delete arg1;
49654     } catch (std::out_of_range& e) {
49655       {
49656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49657       };
49658     } catch (std::exception& e) {
49659       {
49660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49661       };
49662     } catch (...) {
49663       {
49664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49665       };
49666     }
49667   }
49668 }
49669
49670
49671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
49672   unsigned int jresult ;
49673   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49674   bool result;
49675
49676   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49677   {
49678     try {
49679       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
49680     } catch (std::out_of_range& e) {
49681       {
49682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49683       };
49684     } catch (std::exception& e) {
49685       {
49686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49687       };
49688     } catch (...) {
49689       {
49690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49691       };
49692     }
49693   }
49694   jresult = result;
49695   return jresult;
49696 }
49697
49698
49699 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
49700   unsigned long jresult ;
49701   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49702   std::size_t result;
49703
49704   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49705   {
49706     try {
49707       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
49708     } catch (std::out_of_range& e) {
49709       {
49710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49711       };
49712     } catch (std::exception& e) {
49713       {
49714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49715       };
49716     } catch (...) {
49717       {
49718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49719       };
49720     }
49721   }
49722   jresult = (unsigned long)result;
49723   return jresult;
49724 }
49725
49726
49727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
49728   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49729   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49730
49731   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49732   arg2 = (void (*)(Dali::Image))jarg2;
49733   {
49734     try {
49735       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
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 void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
49754   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49755   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49756
49757   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49758   arg2 = (void (*)(Dali::Image))jarg2;
49759   {
49760     try {
49761       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
49762     } catch (std::out_of_range& e) {
49763       {
49764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49765       };
49766     } catch (std::exception& e) {
49767       {
49768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49769       };
49770     } catch (...) {
49771       {
49772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49773       };
49774     }
49775   }
49776 }
49777
49778
49779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
49780   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49781   Dali::Image arg2 ;
49782   Dali::Image *argp2 ;
49783
49784   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49785   argp2 = (Dali::Image *)jarg2;
49786   if (!argp2) {
49787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
49788     return ;
49789   }
49790   arg2 = *argp2;
49791   {
49792     try {
49793       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
49794     } catch (std::out_of_range& e) {
49795       {
49796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49797       };
49798     } catch (std::exception& e) {
49799       {
49800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49801       };
49802     } catch (...) {
49803       {
49804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49805       };
49806     }
49807   }
49808 }
49809
49810
49811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
49812   void * jresult ;
49813   Dali::Signal< void (Dali::Image) > *result = 0 ;
49814
49815   {
49816     try {
49817       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
49818     } catch (std::out_of_range& e) {
49819       {
49820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49821       };
49822     } catch (std::exception& e) {
49823       {
49824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49825       };
49826     } catch (...) {
49827       {
49828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49829       };
49830     }
49831   }
49832   jresult = (void *)result;
49833   return jresult;
49834 }
49835
49836
49837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
49838   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49839
49840   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49841   {
49842     try {
49843       delete arg1;
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_new_RenderTaskSignal() {
49862   void * jresult ;
49863   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
49864
49865   {
49866     try {
49867       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
49868     } catch (std::out_of_range& e) {
49869       {
49870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49871       };
49872     } catch (std::exception& e) {
49873       {
49874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49875       };
49876     } catch (...) {
49877       {
49878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49879       };
49880     }
49881   }
49882   jresult = (void *)result;
49883   return jresult;
49884 }
49885
49886
49887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
49888   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
49889
49890   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
49891   {
49892     try {
49893       delete arg1;
49894     } catch (std::out_of_range& e) {
49895       {
49896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49897       };
49898     } catch (std::exception& e) {
49899       {
49900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49901       };
49902     } catch (...) {
49903       {
49904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49905       };
49906     }
49907   }
49908 }
49909
49910
49911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
49912   unsigned int jresult ;
49913   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49914   bool result;
49915
49916   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49917   {
49918     try {
49919       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);
49920     } catch (std::out_of_range& e) {
49921       {
49922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49923       };
49924     } catch (std::exception& e) {
49925       {
49926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49927       };
49928     } catch (...) {
49929       {
49930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49931       };
49932     }
49933   }
49934   jresult = result;
49935   return jresult;
49936 }
49937
49938
49939 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49940   unsigned long jresult ;
49941   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49942   std::size_t result;
49943
49944   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49945   {
49946     try {
49947       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);
49948     } catch (std::out_of_range& e) {
49949       {
49950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49951       };
49952     } catch (std::exception& e) {
49953       {
49954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49955       };
49956     } catch (...) {
49957       {
49958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49959       };
49960     }
49961   }
49962   jresult = (unsigned long)result;
49963   return jresult;
49964 }
49965
49966
49967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49968   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49969   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49970
49971   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49972   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49973   {
49974     try {
49975       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49976     } catch (std::out_of_range& e) {
49977       {
49978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49979       };
49980     } catch (std::exception& e) {
49981       {
49982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49983       };
49984     } catch (...) {
49985       {
49986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49987       };
49988     }
49989   }
49990 }
49991
49992
49993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49994   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49995   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49996
49997   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49998   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49999   {
50000     try {
50001       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50002     } catch (std::out_of_range& e) {
50003       {
50004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50005       };
50006     } catch (std::exception& e) {
50007       {
50008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50009       };
50010     } catch (...) {
50011       {
50012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50013       };
50014     }
50015   }
50016 }
50017
50018
50019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50020   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50021   Dali::Actor arg2 ;
50022   Dali::LongPressGesture *arg3 = 0 ;
50023   Dali::Actor *argp2 ;
50024
50025   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50026   argp2 = (Dali::Actor *)jarg2;
50027   if (!argp2) {
50028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50029     return ;
50030   }
50031   arg2 = *argp2;
50032   arg3 = (Dali::LongPressGesture *)jarg3;
50033   if (!arg3) {
50034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
50035     return ;
50036   }
50037   {
50038     try {
50039       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
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 void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
50058   void * jresult ;
50059   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
50060
50061   {
50062     try {
50063       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
50064     } catch (std::out_of_range& e) {
50065       {
50066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50067       };
50068     } catch (std::exception& e) {
50069       {
50070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50071       };
50072     } catch (...) {
50073       {
50074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50075       };
50076     }
50077   }
50078   jresult = (void *)result;
50079   return jresult;
50080 }
50081
50082
50083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
50084   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50085
50086   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50087   {
50088     try {
50089       delete arg1;
50090     } catch (std::out_of_range& e) {
50091       {
50092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50093       };
50094     } catch (std::exception& e) {
50095       {
50096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50097       };
50098     } catch (...) {
50099       {
50100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50101       };
50102     }
50103   }
50104 }
50105
50106
50107 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
50108   unsigned int jresult ;
50109   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50110   bool result;
50111
50112   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50113   {
50114     try {
50115       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);
50116     } catch (std::out_of_range& e) {
50117       {
50118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50119       };
50120     } catch (std::exception& e) {
50121       {
50122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50123       };
50124     } catch (...) {
50125       {
50126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50127       };
50128     }
50129   }
50130   jresult = result;
50131   return jresult;
50132 }
50133
50134
50135 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
50136   unsigned long jresult ;
50137   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50138   std::size_t result;
50139
50140   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50141   {
50142     try {
50143       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);
50144     } catch (std::out_of_range& e) {
50145       {
50146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50147       };
50148     } catch (std::exception& e) {
50149       {
50150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50151       };
50152     } catch (...) {
50153       {
50154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50155       };
50156     }
50157   }
50158   jresult = (unsigned long)result;
50159   return jresult;
50160 }
50161
50162
50163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
50164   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50165   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50166
50167   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50168   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50169   {
50170     try {
50171       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50172     } catch (std::out_of_range& e) {
50173       {
50174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50175       };
50176     } catch (std::exception& e) {
50177       {
50178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50179       };
50180     } catch (...) {
50181       {
50182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50183       };
50184     }
50185   }
50186 }
50187
50188
50189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
50190   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50191   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50192
50193   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50194   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50195   {
50196     try {
50197       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50198     } catch (std::out_of_range& e) {
50199       {
50200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50201       };
50202     } catch (std::exception& e) {
50203       {
50204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50205       };
50206     } catch (...) {
50207       {
50208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50209       };
50210     }
50211   }
50212 }
50213
50214
50215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50216   unsigned int jresult ;
50217   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50218   Dali::Actor arg2 ;
50219   Dali::TouchData *arg3 = 0 ;
50220   Dali::Actor *argp2 ;
50221   bool result;
50222
50223   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50224   argp2 = (Dali::Actor *)jarg2;
50225   if (!argp2) {
50226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50227     return 0;
50228   }
50229   arg2 = *argp2;
50230   arg3 = (Dali::TouchData *)jarg3;
50231   if (!arg3) {
50232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
50233     return 0;
50234   }
50235   {
50236     try {
50237       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
50238     } catch (std::out_of_range& e) {
50239       {
50240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50241       };
50242     } catch (std::exception& e) {
50243       {
50244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50245       };
50246     } catch (...) {
50247       {
50248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50249       };
50250     }
50251   }
50252   jresult = result;
50253   return jresult;
50254 }
50255
50256
50257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
50258   void * jresult ;
50259   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
50260
50261   {
50262     try {
50263       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
50264     } catch (std::out_of_range& e) {
50265       {
50266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50267       };
50268     } catch (std::exception& e) {
50269       {
50270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50271       };
50272     } catch (...) {
50273       {
50274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50275       };
50276     }
50277   }
50278   jresult = (void *)result;
50279   return jresult;
50280 }
50281
50282
50283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
50284   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50285
50286   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50287   {
50288     try {
50289       delete arg1;
50290     } catch (std::out_of_range& e) {
50291       {
50292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50293       };
50294     } catch (std::exception& e) {
50295       {
50296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50297       };
50298     } catch (...) {
50299       {
50300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50301       };
50302     }
50303   }
50304 }
50305
50306
50307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
50308   unsigned int jresult ;
50309   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50310   bool result;
50311
50312   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50313   {
50314     try {
50315       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);
50316     } catch (std::out_of_range& e) {
50317       {
50318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50319       };
50320     } catch (std::exception& e) {
50321       {
50322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50323       };
50324     } catch (...) {
50325       {
50326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50327       };
50328     }
50329   }
50330   jresult = result;
50331   return jresult;
50332 }
50333
50334
50335 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
50336   unsigned long jresult ;
50337   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50338   std::size_t result;
50339
50340   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50341   {
50342     try {
50343       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);
50344     } catch (std::out_of_range& e) {
50345       {
50346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50347       };
50348     } catch (std::exception& e) {
50349       {
50350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50351       };
50352     } catch (...) {
50353       {
50354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50355       };
50356     }
50357   }
50358   jresult = (unsigned long)result;
50359   return jresult;
50360 }
50361
50362
50363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
50364   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50365   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50366
50367   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50368   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50369   {
50370     try {
50371       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50372     } catch (std::out_of_range& e) {
50373       {
50374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50375       };
50376     } catch (std::exception& e) {
50377       {
50378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50379       };
50380     } catch (...) {
50381       {
50382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50383       };
50384     }
50385   }
50386 }
50387
50388
50389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
50390   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50391   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50392
50393   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50394   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50395   {
50396     try {
50397       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50398     } catch (std::out_of_range& e) {
50399       {
50400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50401       };
50402     } catch (std::exception& e) {
50403       {
50404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50405       };
50406     } catch (...) {
50407       {
50408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50409       };
50410     }
50411   }
50412 }
50413
50414
50415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50416   unsigned int jresult ;
50417   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50418   Dali::Actor arg2 ;
50419   Dali::HoverEvent *arg3 = 0 ;
50420   Dali::Actor *argp2 ;
50421   bool result;
50422
50423   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50424   argp2 = (Dali::Actor *)jarg2;
50425   if (!argp2) {
50426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50427     return 0;
50428   }
50429   arg2 = *argp2;
50430   arg3 = (Dali::HoverEvent *)jarg3;
50431   if (!arg3) {
50432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
50433     return 0;
50434   }
50435   {
50436     try {
50437       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
50438     } catch (std::out_of_range& e) {
50439       {
50440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50441       };
50442     } catch (std::exception& e) {
50443       {
50444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50445       };
50446     } catch (...) {
50447       {
50448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50449       };
50450     }
50451   }
50452   jresult = result;
50453   return jresult;
50454 }
50455
50456
50457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
50458   void * jresult ;
50459   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
50460
50461   {
50462     try {
50463       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
50464     } catch (std::out_of_range& e) {
50465       {
50466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50467       };
50468     } catch (std::exception& e) {
50469       {
50470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50471       };
50472     } catch (...) {
50473       {
50474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50475       };
50476     }
50477   }
50478   jresult = (void *)result;
50479   return jresult;
50480 }
50481
50482
50483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
50484   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50485
50486   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50487   {
50488     try {
50489       delete arg1;
50490     } catch (std::out_of_range& e) {
50491       {
50492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50493       };
50494     } catch (std::exception& e) {
50495       {
50496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50497       };
50498     } catch (...) {
50499       {
50500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50501       };
50502     }
50503   }
50504 }
50505
50506
50507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
50508   unsigned int jresult ;
50509   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50510   bool result;
50511
50512   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50513   {
50514     try {
50515       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);
50516     } catch (std::out_of_range& e) {
50517       {
50518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50519       };
50520     } catch (std::exception& e) {
50521       {
50522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50523       };
50524     } catch (...) {
50525       {
50526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50527       };
50528     }
50529   }
50530   jresult = result;
50531   return jresult;
50532 }
50533
50534
50535 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
50536   unsigned long jresult ;
50537   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50538   std::size_t result;
50539
50540   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50541   {
50542     try {
50543       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);
50544     } catch (std::out_of_range& e) {
50545       {
50546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50547       };
50548     } catch (std::exception& e) {
50549       {
50550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50551       };
50552     } catch (...) {
50553       {
50554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50555       };
50556     }
50557   }
50558   jresult = (unsigned long)result;
50559   return jresult;
50560 }
50561
50562
50563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
50564   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50565   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50566
50567   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50568   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50569   {
50570     try {
50571       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50572     } catch (std::out_of_range& e) {
50573       {
50574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50575       };
50576     } catch (std::exception& e) {
50577       {
50578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50579       };
50580     } catch (...) {
50581       {
50582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50583       };
50584     }
50585   }
50586 }
50587
50588
50589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
50590   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50591   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50592
50593   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50594   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50595   {
50596     try {
50597       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50598     } catch (std::out_of_range& e) {
50599       {
50600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50601       };
50602     } catch (std::exception& e) {
50603       {
50604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50605       };
50606     } catch (...) {
50607       {
50608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50609       };
50610     }
50611   }
50612 }
50613
50614
50615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50616   unsigned int jresult ;
50617   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50618   Dali::Actor arg2 ;
50619   Dali::WheelEvent *arg3 = 0 ;
50620   Dali::Actor *argp2 ;
50621   bool result;
50622
50623   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50624   argp2 = (Dali::Actor *)jarg2;
50625   if (!argp2) {
50626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50627     return 0;
50628   }
50629   arg2 = *argp2;
50630   arg3 = (Dali::WheelEvent *)jarg3;
50631   if (!arg3) {
50632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
50633     return 0;
50634   }
50635   {
50636     try {
50637       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
50638     } catch (std::out_of_range& e) {
50639       {
50640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50641       };
50642     } catch (std::exception& e) {
50643       {
50644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50645       };
50646     } catch (...) {
50647       {
50648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50649       };
50650     }
50651   }
50652   jresult = result;
50653   return jresult;
50654 }
50655
50656
50657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
50658   void * jresult ;
50659   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
50660
50661   {
50662     try {
50663       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
50664     } catch (std::out_of_range& e) {
50665       {
50666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50667       };
50668     } catch (std::exception& e) {
50669       {
50670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50671       };
50672     } catch (...) {
50673       {
50674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50675       };
50676     }
50677   }
50678   jresult = (void *)result;
50679   return jresult;
50680 }
50681
50682
50683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
50684   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50685
50686   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50687   {
50688     try {
50689       delete arg1;
50690     } catch (std::out_of_range& e) {
50691       {
50692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50693       };
50694     } catch (std::exception& e) {
50695       {
50696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50697       };
50698     } catch (...) {
50699       {
50700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50701       };
50702     }
50703   }
50704 }
50705
50706
50707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
50708   unsigned int jresult ;
50709   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50710   bool result;
50711
50712   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50713   {
50714     try {
50715       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
50716     } catch (std::out_of_range& e) {
50717       {
50718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50719       };
50720     } catch (std::exception& e) {
50721       {
50722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50723       };
50724     } catch (...) {
50725       {
50726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50727       };
50728     }
50729   }
50730   jresult = result;
50731   return jresult;
50732 }
50733
50734
50735 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
50736   unsigned long jresult ;
50737   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50738   std::size_t result;
50739
50740   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50741   {
50742     try {
50743       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
50744     } catch (std::out_of_range& e) {
50745       {
50746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50747       };
50748     } catch (std::exception& e) {
50749       {
50750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50751       };
50752     } catch (...) {
50753       {
50754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50755       };
50756     }
50757   }
50758   jresult = (unsigned long)result;
50759   return jresult;
50760 }
50761
50762
50763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
50764   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50765   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50766
50767   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50768   arg2 = (void (*)(Dali::Actor))jarg2;
50769   {
50770     try {
50771       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
50772     } catch (std::out_of_range& e) {
50773       {
50774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50775       };
50776     } catch (std::exception& e) {
50777       {
50778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50779       };
50780     } catch (...) {
50781       {
50782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50783       };
50784     }
50785   }
50786 }
50787
50788
50789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
50790   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50791   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50792
50793   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50794   arg2 = (void (*)(Dali::Actor))jarg2;
50795   {
50796     try {
50797       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
50798     } catch (std::out_of_range& e) {
50799       {
50800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50801       };
50802     } catch (std::exception& e) {
50803       {
50804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50805       };
50806     } catch (...) {
50807       {
50808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50809       };
50810     }
50811   }
50812 }
50813
50814
50815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
50816   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50817   Dali::Actor arg2 ;
50818   Dali::Actor *argp2 ;
50819
50820   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50821   argp2 = (Dali::Actor *)jarg2;
50822   if (!argp2) {
50823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50824     return ;
50825   }
50826   arg2 = *argp2;
50827   {
50828     try {
50829       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(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_new_ActorSignal() {
50848   void * jresult ;
50849   Dali::Signal< void (Dali::Actor) > *result = 0 ;
50850
50851   {
50852     try {
50853       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
50854     } catch (std::out_of_range& e) {
50855       {
50856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50857       };
50858     } catch (std::exception& e) {
50859       {
50860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50861       };
50862     } catch (...) {
50863       {
50864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50865       };
50866     }
50867   }
50868   jresult = (void *)result;
50869   return jresult;
50870 }
50871
50872
50873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
50874   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50875
50876   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50877   {
50878     try {
50879       delete arg1;
50880     } catch (std::out_of_range& e) {
50881       {
50882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50883       };
50884     } catch (std::exception& e) {
50885       {
50886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50887       };
50888     } catch (...) {
50889       {
50890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50891       };
50892     }
50893   }
50894 }
50895
50896
50897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
50898   unsigned int jresult ;
50899   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50900   bool result;
50901
50902   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50903   {
50904     try {
50905       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50906     } catch (std::out_of_range& e) {
50907       {
50908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50909       };
50910     } catch (std::exception& e) {
50911       {
50912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50913       };
50914     } catch (...) {
50915       {
50916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50917       };
50918     }
50919   }
50920   jresult = result;
50921   return jresult;
50922 }
50923
50924
50925 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
50926   unsigned long jresult ;
50927   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50928   std::size_t result;
50929
50930   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50931   {
50932     try {
50933       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50934     } catch (std::out_of_range& e) {
50935       {
50936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50937       };
50938     } catch (std::exception& e) {
50939       {
50940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50941       };
50942     } catch (...) {
50943       {
50944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50945       };
50946     }
50947   }
50948   jresult = (unsigned long)result;
50949   return jresult;
50950 }
50951
50952
50953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
50954   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50955   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50956
50957   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50958   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50959   {
50960     try {
50961       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50962     } catch (std::out_of_range& e) {
50963       {
50964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50965       };
50966     } catch (std::exception& e) {
50967       {
50968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50969       };
50970     } catch (...) {
50971       {
50972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50973       };
50974     }
50975   }
50976 }
50977
50978
50979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
50980   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50981   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50982
50983   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50984   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50985   {
50986     try {
50987       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50988     } catch (std::out_of_range& e) {
50989       {
50990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50991       };
50992     } catch (std::exception& e) {
50993       {
50994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50995       };
50996     } catch (...) {
50997       {
50998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50999       };
51000     }
51001   }
51002 }
51003
51004
51005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
51006   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51007   Dali::KeyEvent *arg2 = 0 ;
51008
51009   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51010   arg2 = (Dali::KeyEvent *)jarg2;
51011   if (!arg2) {
51012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
51013     return ;
51014   }
51015   {
51016     try {
51017       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*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_new_KeyEventSignal() {
51036   void * jresult ;
51037   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
51038
51039   {
51040     try {
51041       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
51042     } catch (std::out_of_range& e) {
51043       {
51044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51045       };
51046     } catch (std::exception& e) {
51047       {
51048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51049       };
51050     } catch (...) {
51051       {
51052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51053       };
51054     }
51055   }
51056   jresult = (void *)result;
51057   return jresult;
51058 }
51059
51060
51061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
51062   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51063
51064   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51065   {
51066     try {
51067       delete arg1;
51068     } catch (std::out_of_range& e) {
51069       {
51070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51071       };
51072     } catch (std::exception& e) {
51073       {
51074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51075       };
51076     } catch (...) {
51077       {
51078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51079       };
51080     }
51081   }
51082 }
51083
51084
51085 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
51086   unsigned int jresult ;
51087   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51088   bool result;
51089
51090   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51091   {
51092     try {
51093       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51094     } catch (std::out_of_range& e) {
51095       {
51096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51097       };
51098     } catch (std::exception& e) {
51099       {
51100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51101       };
51102     } catch (...) {
51103       {
51104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51105       };
51106     }
51107   }
51108   jresult = result;
51109   return jresult;
51110 }
51111
51112
51113 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
51114   unsigned long jresult ;
51115   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51116   std::size_t result;
51117
51118   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51119   {
51120     try {
51121       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51122     } catch (std::out_of_range& e) {
51123       {
51124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51125       };
51126     } catch (std::exception& e) {
51127       {
51128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51129       };
51130     } catch (...) {
51131       {
51132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51133       };
51134     }
51135   }
51136   jresult = (unsigned long)result;
51137   return jresult;
51138 }
51139
51140
51141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
51142   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51143   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51144
51145   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51146   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51147   {
51148     try {
51149       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51150     } catch (std::out_of_range& e) {
51151       {
51152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51153       };
51154     } catch (std::exception& e) {
51155       {
51156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51157       };
51158     } catch (...) {
51159       {
51160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51161       };
51162     }
51163   }
51164 }
51165
51166
51167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
51168   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51169   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51170
51171   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51172   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51173   {
51174     try {
51175       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51176     } catch (std::out_of_range& e) {
51177       {
51178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51179       };
51180     } catch (std::exception& e) {
51181       {
51182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51183       };
51184     } catch (...) {
51185       {
51186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51187       };
51188     }
51189   }
51190 }
51191
51192
51193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
51194   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51195   Dali::TouchData *arg2 = 0 ;
51196
51197   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51198   arg2 = (Dali::TouchData *)jarg2;
51199   if (!arg2) {
51200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51201     return ;
51202   }
51203   {
51204     try {
51205       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*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_new_TouchSignal() {
51224   void * jresult ;
51225   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
51226
51227   {
51228     try {
51229       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
51230     } catch (std::out_of_range& e) {
51231       {
51232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51233       };
51234     } catch (std::exception& e) {
51235       {
51236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51237       };
51238     } catch (...) {
51239       {
51240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51241       };
51242     }
51243   }
51244   jresult = (void *)result;
51245   return jresult;
51246 }
51247
51248
51249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
51250   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51251
51252   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51253   {
51254     try {
51255       delete arg1;
51256     } catch (std::out_of_range& e) {
51257       {
51258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51259       };
51260     } catch (std::exception& e) {
51261       {
51262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51263       };
51264     } catch (...) {
51265       {
51266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51267       };
51268     }
51269   }
51270 }
51271
51272
51273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
51274   unsigned int jresult ;
51275   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51276   bool result;
51277
51278   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51279   {
51280     try {
51281       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51282     } catch (std::out_of_range& e) {
51283       {
51284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51285       };
51286     } catch (std::exception& e) {
51287       {
51288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51289       };
51290     } catch (...) {
51291       {
51292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51293       };
51294     }
51295   }
51296   jresult = result;
51297   return jresult;
51298 }
51299
51300
51301 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
51302   unsigned long jresult ;
51303   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51304   std::size_t result;
51305
51306   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51307   {
51308     try {
51309       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
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 = (unsigned long)result;
51325   return jresult;
51326 }
51327
51328
51329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
51330   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51331   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51332
51333   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51334   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51335   {
51336     try {
51337       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51338     } catch (std::out_of_range& e) {
51339       {
51340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51341       };
51342     } catch (std::exception& e) {
51343       {
51344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51345       };
51346     } catch (...) {
51347       {
51348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51349       };
51350     }
51351   }
51352 }
51353
51354
51355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
51356   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51357   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51358
51359   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51360   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51361   {
51362     try {
51363       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51364     } catch (std::out_of_range& e) {
51365       {
51366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51367       };
51368     } catch (std::exception& e) {
51369       {
51370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51371       };
51372     } catch (...) {
51373       {
51374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51375       };
51376     }
51377   }
51378 }
51379
51380
51381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
51382   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51383   Dali::WheelEvent *arg2 = 0 ;
51384
51385   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51386   arg2 = (Dali::WheelEvent *)jarg2;
51387   if (!arg2) {
51388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51389     return ;
51390   }
51391   {
51392     try {
51393       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
51394     } catch (std::out_of_range& e) {
51395       {
51396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51397       };
51398     } catch (std::exception& e) {
51399       {
51400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51401       };
51402     } catch (...) {
51403       {
51404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51405       };
51406     }
51407   }
51408 }
51409
51410
51411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
51412   void * jresult ;
51413   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
51414
51415   {
51416     try {
51417       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
51418     } catch (std::out_of_range& e) {
51419       {
51420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51421       };
51422     } catch (std::exception& e) {
51423       {
51424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51425       };
51426     } catch (...) {
51427       {
51428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51429       };
51430     }
51431   }
51432   jresult = (void *)result;
51433   return jresult;
51434 }
51435
51436
51437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
51438   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51439
51440   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51441   {
51442     try {
51443       delete arg1;
51444     } catch (std::out_of_range& e) {
51445       {
51446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51447       };
51448     } catch (std::exception& e) {
51449       {
51450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51451       };
51452     } catch (...) {
51453       {
51454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51455       };
51456     }
51457   }
51458 }
51459
51460
51461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
51462   void * jresult ;
51463   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51464
51465   {
51466     try {
51467       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
51468     } catch (std::out_of_range& e) {
51469       {
51470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51471       };
51472     } catch (std::exception& e) {
51473       {
51474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51475       };
51476     } catch (...) {
51477       {
51478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51479       };
51480     }
51481   }
51482   jresult = (void *)result;
51483   return jresult;
51484 }
51485
51486
51487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
51488   void * jresult ;
51489   Dali::Radian arg1 ;
51490   Dali::Radian arg2 ;
51491   Dali::Radian *argp1 ;
51492   Dali::Radian *argp2 ;
51493   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51494
51495   argp1 = (Dali::Radian *)jarg1;
51496   if (!argp1) {
51497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51498     return 0;
51499   }
51500   arg1 = *argp1;
51501   argp2 = (Dali::Radian *)jarg2;
51502   if (!argp2) {
51503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51504     return 0;
51505   }
51506   arg2 = *argp2;
51507   {
51508     try {
51509       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
51510     } catch (std::out_of_range& e) {
51511       {
51512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51513       };
51514     } catch (std::exception& e) {
51515       {
51516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51517       };
51518     } catch (...) {
51519       {
51520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51521       };
51522     }
51523   }
51524   jresult = (void *)result;
51525   return jresult;
51526 }
51527
51528
51529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
51530   void * jresult ;
51531   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
51532   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51533
51534   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51535   if (!arg1) {
51536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
51537     return 0;
51538   }
51539   {
51540     try {
51541       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
51542     } catch (std::out_of_range& e) {
51543       {
51544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51545       };
51546     } catch (std::exception& e) {
51547       {
51548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51549       };
51550     } catch (...) {
51551       {
51552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51553       };
51554     }
51555   }
51556   jresult = (void *)result;
51557   return jresult;
51558 }
51559
51560
51561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
51562   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51563   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51564
51565   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51566   arg2 = (Dali::Radian *)jarg2;
51567   if (arg1) (arg1)->first = *arg2;
51568 }
51569
51570
51571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
51572   void * jresult ;
51573   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51574   Dali::Radian *result = 0 ;
51575
51576   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51577   result = (Dali::Radian *)& ((arg1)->first);
51578   jresult = (void *)result;
51579   return jresult;
51580 }
51581
51582
51583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
51584   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51585   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51586
51587   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51588   arg2 = (Dali::Radian *)jarg2;
51589   if (arg1) (arg1)->second = *arg2;
51590 }
51591
51592
51593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
51594   void * jresult ;
51595   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51596   Dali::Radian *result = 0 ;
51597
51598   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51599   result = (Dali::Radian *)& ((arg1)->second);
51600   jresult = (void *)result;
51601   return jresult;
51602 }
51603
51604
51605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
51606   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51607
51608   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51609   {
51610     try {
51611       delete arg1;
51612     } catch (std::out_of_range& e) {
51613       {
51614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51615       };
51616     } catch (std::exception& e) {
51617       {
51618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51619       };
51620     } catch (...) {
51621       {
51622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51623       };
51624     }
51625   }
51626 }
51627
51628
51629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
51630   unsigned int jresult ;
51631   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51632   bool result;
51633
51634   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51635   {
51636     try {
51637       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);
51638     } catch (std::out_of_range& e) {
51639       {
51640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51641       };
51642     } catch (std::exception& e) {
51643       {
51644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51645       };
51646     } catch (...) {
51647       {
51648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51649       };
51650     }
51651   }
51652   jresult = result;
51653   return jresult;
51654 }
51655
51656
51657 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51658   unsigned long jresult ;
51659   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51660   std::size_t result;
51661
51662   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51663   {
51664     try {
51665       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);
51666     } catch (std::out_of_range& e) {
51667       {
51668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51669       };
51670     } catch (std::exception& e) {
51671       {
51672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51673       };
51674     } catch (...) {
51675       {
51676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51677       };
51678     }
51679   }
51680   jresult = (unsigned long)result;
51681   return jresult;
51682 }
51683
51684
51685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51686   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51687   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51688
51689   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51690   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51691   {
51692     try {
51693       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51694     } catch (std::out_of_range& e) {
51695       {
51696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51697       };
51698     } catch (std::exception& e) {
51699       {
51700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51701       };
51702     } catch (...) {
51703       {
51704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51705       };
51706     }
51707   }
51708 }
51709
51710
51711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51712   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51713   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51714
51715   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51716   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51717   {
51718     try {
51719       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51720     } catch (std::out_of_range& e) {
51721       {
51722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51723       };
51724     } catch (std::exception& e) {
51725       {
51726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51727       };
51728     } catch (...) {
51729       {
51730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51731       };
51732     }
51733   }
51734 }
51735
51736
51737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51738   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51739   Dali::Actor arg2 ;
51740   Dali::PanGesture *arg3 = 0 ;
51741   Dali::Actor *argp2 ;
51742
51743   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51744   argp2 = (Dali::Actor *)jarg2;
51745   if (!argp2) {
51746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51747     return ;
51748   }
51749   arg2 = *argp2;
51750   arg3 = (Dali::PanGesture *)jarg3;
51751   if (!arg3) {
51752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
51753     return ;
51754   }
51755   {
51756     try {
51757       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
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_new_PanGestureDetectedSignal() {
51776   void * jresult ;
51777   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
51778
51779   {
51780     try {
51781       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
51782     } catch (std::out_of_range& e) {
51783       {
51784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51785       };
51786     } catch (std::exception& e) {
51787       {
51788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51789       };
51790     } catch (...) {
51791       {
51792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51793       };
51794     }
51795   }
51796   jresult = (void *)result;
51797   return jresult;
51798 }
51799
51800
51801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
51802   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51803
51804   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51805   {
51806     try {
51807       delete arg1;
51808     } catch (std::out_of_range& e) {
51809       {
51810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51811       };
51812     } catch (std::exception& e) {
51813       {
51814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51815       };
51816     } catch (...) {
51817       {
51818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51819       };
51820     }
51821   }
51822 }
51823
51824
51825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
51826   unsigned int jresult ;
51827   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51828   bool result;
51829
51830   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51831   {
51832     try {
51833       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);
51834     } catch (std::out_of_range& e) {
51835       {
51836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51837       };
51838     } catch (std::exception& e) {
51839       {
51840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51841       };
51842     } catch (...) {
51843       {
51844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51845       };
51846     }
51847   }
51848   jresult = result;
51849   return jresult;
51850 }
51851
51852
51853 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51854   unsigned long jresult ;
51855   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51856   std::size_t result;
51857
51858   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51859   {
51860     try {
51861       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);
51862     } catch (std::out_of_range& e) {
51863       {
51864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51865       };
51866     } catch (std::exception& e) {
51867       {
51868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51869       };
51870     } catch (...) {
51871       {
51872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51873       };
51874     }
51875   }
51876   jresult = (unsigned long)result;
51877   return jresult;
51878 }
51879
51880
51881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51882   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51883   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51884
51885   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51886   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51887   {
51888     try {
51889       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51890     } catch (std::out_of_range& e) {
51891       {
51892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51893       };
51894     } catch (std::exception& e) {
51895       {
51896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51897       };
51898     } catch (...) {
51899       {
51900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51901       };
51902     }
51903   }
51904 }
51905
51906
51907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51908   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51909   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51910
51911   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51912   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51913   {
51914     try {
51915       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51916     } catch (std::out_of_range& e) {
51917       {
51918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51919       };
51920     } catch (std::exception& e) {
51921       {
51922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51923       };
51924     } catch (...) {
51925       {
51926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51927       };
51928     }
51929   }
51930 }
51931
51932
51933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51934   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51935   Dali::Actor arg2 ;
51936   Dali::PinchGesture *arg3 = 0 ;
51937   Dali::Actor *argp2 ;
51938
51939   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51940   argp2 = (Dali::Actor *)jarg2;
51941   if (!argp2) {
51942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51943     return ;
51944   }
51945   arg2 = *argp2;
51946   arg3 = (Dali::PinchGesture *)jarg3;
51947   if (!arg3) {
51948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
51949     return ;
51950   }
51951   {
51952     try {
51953       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
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_new_PinchGestureDetectedSignal() {
51972   void * jresult ;
51973   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
51974
51975   {
51976     try {
51977       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
51978     } catch (std::out_of_range& e) {
51979       {
51980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51981       };
51982     } catch (std::exception& e) {
51983       {
51984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51985       };
51986     } catch (...) {
51987       {
51988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51989       };
51990     }
51991   }
51992   jresult = (void *)result;
51993   return jresult;
51994 }
51995
51996
51997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
51998   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51999
52000   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
52001   {
52002     try {
52003       delete arg1;
52004     } catch (std::out_of_range& e) {
52005       {
52006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52007       };
52008     } catch (std::exception& e) {
52009       {
52010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52011       };
52012     } catch (...) {
52013       {
52014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52015       };
52016     }
52017   }
52018 }
52019
52020
52021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
52022   unsigned int jresult ;
52023   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52024   bool result;
52025
52026   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52027   {
52028     try {
52029       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);
52030     } catch (std::out_of_range& e) {
52031       {
52032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52033       };
52034     } catch (std::exception& e) {
52035       {
52036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52037       };
52038     } catch (...) {
52039       {
52040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52041       };
52042     }
52043   }
52044   jresult = result;
52045   return jresult;
52046 }
52047
52048
52049 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
52050   unsigned long jresult ;
52051   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52052   std::size_t result;
52053
52054   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52055   {
52056     try {
52057       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);
52058     } catch (std::out_of_range& e) {
52059       {
52060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52061       };
52062     } catch (std::exception& e) {
52063       {
52064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52065       };
52066     } catch (...) {
52067       {
52068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52069       };
52070     }
52071   }
52072   jresult = (unsigned long)result;
52073   return jresult;
52074 }
52075
52076
52077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
52078   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52079   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52080
52081   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52082   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52083   {
52084     try {
52085       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52086     } catch (std::out_of_range& e) {
52087       {
52088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52089       };
52090     } catch (std::exception& e) {
52091       {
52092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52093       };
52094     } catch (...) {
52095       {
52096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52097       };
52098     }
52099   }
52100 }
52101
52102
52103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
52104   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52105   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52106
52107   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52108   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52109   {
52110     try {
52111       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52112     } catch (std::out_of_range& e) {
52113       {
52114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52115       };
52116     } catch (std::exception& e) {
52117       {
52118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52119       };
52120     } catch (...) {
52121       {
52122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52123       };
52124     }
52125   }
52126 }
52127
52128
52129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52130   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52131   Dali::Actor arg2 ;
52132   Dali::TapGesture *arg3 = 0 ;
52133   Dali::Actor *argp2 ;
52134
52135   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52136   argp2 = (Dali::Actor *)jarg2;
52137   if (!argp2) {
52138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52139     return ;
52140   }
52141   arg2 = *argp2;
52142   arg3 = (Dali::TapGesture *)jarg3;
52143   if (!arg3) {
52144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
52145     return ;
52146   }
52147   {
52148     try {
52149       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
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_new_TapGestureDetectedSignal() {
52168   void * jresult ;
52169   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
52170
52171   {
52172     try {
52173       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
52174     } catch (std::out_of_range& e) {
52175       {
52176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52177       };
52178     } catch (std::exception& e) {
52179       {
52180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52181       };
52182     } catch (...) {
52183       {
52184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52185       };
52186     }
52187   }
52188   jresult = (void *)result;
52189   return jresult;
52190 }
52191
52192
52193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
52194   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52195
52196   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52197   {
52198     try {
52199       delete arg1;
52200     } catch (std::out_of_range& e) {
52201       {
52202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52203       };
52204     } catch (std::exception& e) {
52205       {
52206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52207       };
52208     } catch (...) {
52209       {
52210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52211       };
52212     }
52213   }
52214 }
52215
52216
52217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
52218   unsigned int jresult ;
52219   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52220   bool result;
52221
52222   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52223   {
52224     try {
52225       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52226     } catch (std::out_of_range& e) {
52227       {
52228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52229       };
52230     } catch (std::exception& e) {
52231       {
52232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52233       };
52234     } catch (...) {
52235       {
52236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52237       };
52238     }
52239   }
52240   jresult = result;
52241   return jresult;
52242 }
52243
52244
52245 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
52246   unsigned long jresult ;
52247   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52248   std::size_t result;
52249
52250   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52251   {
52252     try {
52253       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52254     } catch (std::out_of_range& e) {
52255       {
52256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52257       };
52258     } catch (std::exception& e) {
52259       {
52260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52261       };
52262     } catch (...) {
52263       {
52264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52265       };
52266     }
52267   }
52268   jresult = (unsigned long)result;
52269   return jresult;
52270 }
52271
52272
52273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
52274   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52275   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52276
52277   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52278   arg2 = (void (*)(Dali::Animation &))jarg2;
52279   {
52280     try {
52281       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
52282     } catch (std::out_of_range& e) {
52283       {
52284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52285       };
52286     } catch (std::exception& e) {
52287       {
52288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52289       };
52290     } catch (...) {
52291       {
52292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52293       };
52294     }
52295   }
52296 }
52297
52298
52299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
52300   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52301   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52302
52303   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52304   arg2 = (void (*)(Dali::Animation &))jarg2;
52305   {
52306     try {
52307       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
52308     } catch (std::out_of_range& e) {
52309       {
52310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52311       };
52312     } catch (std::exception& e) {
52313       {
52314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52315       };
52316     } catch (...) {
52317       {
52318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52319       };
52320     }
52321   }
52322 }
52323
52324
52325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
52326   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52327   Dali::Animation *arg2 = 0 ;
52328
52329   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52330   arg2 = (Dali::Animation *)jarg2;
52331   if (!arg2) {
52332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
52333     return ;
52334   }
52335   {
52336     try {
52337       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(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_new_AnimationSignal() {
52356   void * jresult ;
52357   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
52358
52359   {
52360     try {
52361       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
52362     } catch (std::out_of_range& e) {
52363       {
52364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52365       };
52366     } catch (std::exception& e) {
52367       {
52368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52369       };
52370     } catch (...) {
52371       {
52372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52373       };
52374     }
52375   }
52376   jresult = (void *)result;
52377   return jresult;
52378 }
52379
52380
52381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
52382   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52383
52384   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52385   {
52386     try {
52387       delete arg1;
52388     } catch (std::out_of_range& e) {
52389       {
52390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52391       };
52392     } catch (std::exception& e) {
52393       {
52394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52395       };
52396     } catch (...) {
52397       {
52398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52399       };
52400     }
52401   }
52402 }
52403
52404
52405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
52406   unsigned int jresult ;
52407   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52408   bool result;
52409
52410   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52411   {
52412     try {
52413       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52414     } catch (std::out_of_range& e) {
52415       {
52416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52417       };
52418     } catch (std::exception& e) {
52419       {
52420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52421       };
52422     } catch (...) {
52423       {
52424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52425       };
52426     }
52427   }
52428   jresult = result;
52429   return jresult;
52430 }
52431
52432
52433 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
52434   unsigned long jresult ;
52435   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52436   std::size_t result;
52437
52438   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52439   {
52440     try {
52441       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52442     } catch (std::out_of_range& e) {
52443       {
52444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52445       };
52446     } catch (std::exception& e) {
52447       {
52448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52449       };
52450     } catch (...) {
52451       {
52452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52453       };
52454     }
52455   }
52456   jresult = (unsigned long)result;
52457   return jresult;
52458 }
52459
52460
52461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
52462   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52463   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52464
52465   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52466   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52467   {
52468     try {
52469       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
52470     } catch (std::out_of_range& e) {
52471       {
52472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52473       };
52474     } catch (std::exception& e) {
52475       {
52476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52477       };
52478     } catch (...) {
52479       {
52480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52481       };
52482     }
52483   }
52484 }
52485
52486
52487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
52488   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52489   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52490
52491   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52492   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52493   {
52494     try {
52495       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
52496     } catch (std::out_of_range& e) {
52497       {
52498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52499       };
52500     } catch (std::exception& e) {
52501       {
52502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52503       };
52504     } catch (...) {
52505       {
52506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52507       };
52508     }
52509   }
52510 }
52511
52512
52513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
52514   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52515   Dali::ResourceImage arg2 ;
52516   Dali::ResourceImage *argp2 ;
52517
52518   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52519   argp2 = (Dali::ResourceImage *)jarg2;
52520   if (!argp2) {
52521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
52522     return ;
52523   }
52524   arg2 = *argp2;
52525   {
52526     try {
52527       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
52528     } catch (std::out_of_range& e) {
52529       {
52530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52531       };
52532     } catch (std::exception& e) {
52533       {
52534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52535       };
52536     } catch (...) {
52537       {
52538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52539       };
52540     }
52541   }
52542 }
52543
52544
52545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
52546   void * jresult ;
52547   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
52548
52549   {
52550     try {
52551       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
52552     } catch (std::out_of_range& e) {
52553       {
52554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52555       };
52556     } catch (std::exception& e) {
52557       {
52558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52559       };
52560     } catch (...) {
52561       {
52562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52563       };
52564     }
52565   }
52566   jresult = (void *)result;
52567   return jresult;
52568 }
52569
52570
52571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
52572   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52573
52574   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52575   {
52576     try {
52577       delete arg1;
52578     } catch (std::out_of_range& e) {
52579       {
52580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52581       };
52582     } catch (std::exception& e) {
52583       {
52584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52585       };
52586     } catch (...) {
52587       {
52588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52589       };
52590     }
52591   }
52592 }
52593
52594
52595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
52596   void * jresult ;
52597   Dali::Timer *result = 0 ;
52598
52599   {
52600     try {
52601       result = (Dali::Timer *)new Dali::Timer();
52602     } catch (std::out_of_range& e) {
52603       {
52604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52605       };
52606     } catch (std::exception& e) {
52607       {
52608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52609       };
52610     } catch (...) {
52611       {
52612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52613       };
52614     }
52615   }
52616   jresult = (void *)result;
52617   return jresult;
52618 }
52619
52620
52621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
52622   void * jresult ;
52623   unsigned int arg1 ;
52624   Dali::Timer result;
52625
52626   arg1 = (unsigned int)jarg1;
52627   {
52628     try {
52629       result = Dali::Timer::New(arg1);
52630     } catch (std::out_of_range& e) {
52631       {
52632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52633       };
52634     } catch (std::exception& e) {
52635       {
52636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52637       };
52638     } catch (...) {
52639       {
52640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52641       };
52642     }
52643   }
52644   jresult = new Dali::Timer((const Dali::Timer &)result);
52645   return jresult;
52646 }
52647
52648
52649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
52650   void * jresult ;
52651   Dali::Timer *arg1 = 0 ;
52652   Dali::Timer *result = 0 ;
52653
52654   arg1 = (Dali::Timer *)jarg1;
52655   if (!arg1) {
52656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52657     return 0;
52658   }
52659   {
52660     try {
52661       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
52662     } catch (std::out_of_range& e) {
52663       {
52664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52665       };
52666     } catch (std::exception& e) {
52667       {
52668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52669       };
52670     } catch (...) {
52671       {
52672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52673       };
52674     }
52675   }
52676   jresult = (void *)result;
52677   return jresult;
52678 }
52679
52680
52681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
52682   void * jresult ;
52683   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52684   Dali::Timer *arg2 = 0 ;
52685   Dali::Timer *result = 0 ;
52686
52687   arg1 = (Dali::Timer *)jarg1;
52688   arg2 = (Dali::Timer *)jarg2;
52689   if (!arg2) {
52690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52691     return 0;
52692   }
52693   {
52694     try {
52695       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
52696     } catch (std::out_of_range& e) {
52697       {
52698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52699       };
52700     } catch (std::exception& e) {
52701       {
52702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52703       };
52704     } catch (...) {
52705       {
52706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52707       };
52708     }
52709   }
52710   jresult = (void *)result;
52711   return jresult;
52712 }
52713
52714
52715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
52716   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52717
52718   arg1 = (Dali::Timer *)jarg1;
52719   {
52720     try {
52721       delete arg1;
52722     } catch (std::out_of_range& e) {
52723       {
52724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52725       };
52726     } catch (std::exception& e) {
52727       {
52728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52729       };
52730     } catch (...) {
52731       {
52732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52733       };
52734     }
52735   }
52736 }
52737
52738
52739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
52740   void * jresult ;
52741   Dali::BaseHandle arg1 ;
52742   Dali::BaseHandle *argp1 ;
52743   Dali::Timer result;
52744
52745   argp1 = (Dali::BaseHandle *)jarg1;
52746   if (!argp1) {
52747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52748     return 0;
52749   }
52750   arg1 = *argp1;
52751   {
52752     try {
52753       result = Dali::Timer::DownCast(arg1);
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 = new Dali::Timer((const Dali::Timer &)result);
52769   return jresult;
52770 }
52771
52772
52773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
52774   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52775
52776   arg1 = (Dali::Timer *)jarg1;
52777   {
52778     try {
52779       (arg1)->Start();
52780     } catch (std::out_of_range& e) {
52781       {
52782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52783       };
52784     } catch (std::exception& e) {
52785       {
52786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52787       };
52788     } catch (...) {
52789       {
52790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52791       };
52792     }
52793   }
52794 }
52795
52796
52797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
52798   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52799
52800   arg1 = (Dali::Timer *)jarg1;
52801   {
52802     try {
52803       (arg1)->Stop();
52804     } catch (std::out_of_range& e) {
52805       {
52806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52807       };
52808     } catch (std::exception& e) {
52809       {
52810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52811       };
52812     } catch (...) {
52813       {
52814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52815       };
52816     }
52817   }
52818 }
52819
52820
52821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
52822   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52823   unsigned int arg2 ;
52824
52825   arg1 = (Dali::Timer *)jarg1;
52826   arg2 = (unsigned int)jarg2;
52827   {
52828     try {
52829       (arg1)->SetInterval(arg2);
52830     } catch (std::out_of_range& e) {
52831       {
52832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52833       };
52834     } catch (std::exception& e) {
52835       {
52836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52837       };
52838     } catch (...) {
52839       {
52840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52841       };
52842     }
52843   }
52844 }
52845
52846
52847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
52848   unsigned int jresult ;
52849   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52850   unsigned int result;
52851
52852   arg1 = (Dali::Timer *)jarg1;
52853   {
52854     try {
52855       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
52856     } catch (std::out_of_range& e) {
52857       {
52858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52859       };
52860     } catch (std::exception& e) {
52861       {
52862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52863       };
52864     } catch (...) {
52865       {
52866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52867       };
52868     }
52869   }
52870   jresult = result;
52871   return jresult;
52872 }
52873
52874
52875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
52876   unsigned int jresult ;
52877   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52878   bool result;
52879
52880   arg1 = (Dali::Timer *)jarg1;
52881   {
52882     try {
52883       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
52884     } catch (std::out_of_range& e) {
52885       {
52886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52887       };
52888     } catch (std::exception& e) {
52889       {
52890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52891       };
52892     } catch (...) {
52893       {
52894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52895       };
52896     }
52897   }
52898   jresult = result;
52899   return jresult;
52900 }
52901
52902
52903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
52904   void * jresult ;
52905   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52906   Dali::Timer::TimerSignalType *result = 0 ;
52907
52908   arg1 = (Dali::Timer *)jarg1;
52909   {
52910     try {
52911       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
52912     } catch (std::out_of_range& e) {
52913       {
52914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52915       };
52916     } catch (std::exception& e) {
52917       {
52918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52919       };
52920     } catch (...) {
52921       {
52922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52923       };
52924     }
52925   }
52926   jresult = (void *)result;
52927   return jresult;
52928 }
52929
52930
52931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
52932   void * jresult ;
52933   Dali::DragAndDropDetector *result = 0 ;
52934
52935   {
52936     try {
52937       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
52938     } catch (std::out_of_range& e) {
52939       {
52940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52941       };
52942     } catch (std::exception& e) {
52943       {
52944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52945       };
52946     } catch (...) {
52947       {
52948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52949       };
52950     }
52951   }
52952   jresult = (void *)result;
52953   return jresult;
52954 }
52955
52956
52957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
52958   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52959
52960   arg1 = (Dali::DragAndDropDetector *)jarg1;
52961   {
52962     try {
52963       delete arg1;
52964     } catch (std::out_of_range& e) {
52965       {
52966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52967       };
52968     } catch (std::exception& e) {
52969       {
52970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52971       };
52972     } catch (...) {
52973       {
52974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52975       };
52976     }
52977   }
52978 }
52979
52980
52981 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
52982   char * jresult ;
52983   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52984   std::string *result = 0 ;
52985
52986   arg1 = (Dali::DragAndDropDetector *)jarg1;
52987   {
52988     try {
52989       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
52990     } catch (std::out_of_range& e) {
52991       {
52992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52993       };
52994     } catch (std::exception& e) {
52995       {
52996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52997       };
52998     } catch (...) {
52999       {
53000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53001       };
53002     }
53003   }
53004   jresult = SWIG_csharp_string_callback(result->c_str());
53005   return jresult;
53006 }
53007
53008
53009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
53010   void * jresult ;
53011   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53012   Dali::Vector2 result;
53013
53014   arg1 = (Dali::DragAndDropDetector *)jarg1;
53015   {
53016     try {
53017       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
53018     } catch (std::out_of_range& e) {
53019       {
53020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53021       };
53022     } catch (std::exception& e) {
53023       {
53024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53025       };
53026     } catch (...) {
53027       {
53028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53029       };
53030     }
53031   }
53032   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
53033   return jresult;
53034 }
53035
53036
53037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
53038   void * jresult ;
53039   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53040   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53041
53042   arg1 = (Dali::DragAndDropDetector *)jarg1;
53043   {
53044     try {
53045       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
53046     } catch (std::out_of_range& e) {
53047       {
53048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53049       };
53050     } catch (std::exception& e) {
53051       {
53052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53053       };
53054     } catch (...) {
53055       {
53056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53057       };
53058     }
53059   }
53060   jresult = (void *)result;
53061   return jresult;
53062 }
53063
53064
53065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
53066   void * jresult ;
53067   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53068   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53069
53070   arg1 = (Dali::DragAndDropDetector *)jarg1;
53071   {
53072     try {
53073       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
53074     } catch (std::out_of_range& e) {
53075       {
53076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53077       };
53078     } catch (std::exception& e) {
53079       {
53080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53081       };
53082     } catch (...) {
53083       {
53084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53085       };
53086     }
53087   }
53088   jresult = (void *)result;
53089   return jresult;
53090 }
53091
53092
53093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
53094   void * jresult ;
53095   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53096   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53097
53098   arg1 = (Dali::DragAndDropDetector *)jarg1;
53099   {
53100     try {
53101       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
53102     } catch (std::out_of_range& e) {
53103       {
53104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53105       };
53106     } catch (std::exception& e) {
53107       {
53108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53109       };
53110     } catch (...) {
53111       {
53112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53113       };
53114     }
53115   }
53116   jresult = (void *)result;
53117   return jresult;
53118 }
53119
53120
53121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
53122   void * jresult ;
53123   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53124   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53125
53126   arg1 = (Dali::DragAndDropDetector *)jarg1;
53127   {
53128     try {
53129       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
53130     } catch (std::out_of_range& e) {
53131       {
53132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53133       };
53134     } catch (std::exception& e) {
53135       {
53136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53137       };
53138     } catch (...) {
53139       {
53140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53141       };
53142     }
53143   }
53144   jresult = (void *)result;
53145   return jresult;
53146 }
53147
53148
53149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
53150   void * jresult ;
53151   Dali::ApplicationExtensions *result = 0 ;
53152
53153   {
53154     try {
53155       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
53156     } catch (std::out_of_range& e) {
53157       {
53158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53159       };
53160     } catch (std::exception& e) {
53161       {
53162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53163       };
53164     } catch (...) {
53165       {
53166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53167       };
53168     }
53169   }
53170   jresult = (void *)result;
53171   return jresult;
53172 }
53173
53174
53175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
53176   void * jresult ;
53177   Dali::Application *arg1 = (Dali::Application *) 0 ;
53178   Dali::ApplicationExtensions *result = 0 ;
53179
53180   arg1 = (Dali::Application *)jarg1;
53181   {
53182     try {
53183       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
53184     } catch (std::out_of_range& e) {
53185       {
53186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53187       };
53188     } catch (std::exception& e) {
53189       {
53190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53191       };
53192     } catch (...) {
53193       {
53194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53195       };
53196     }
53197   }
53198   jresult = (void *)result;
53199   return jresult;
53200 }
53201
53202
53203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
53204   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53205
53206   arg1 = (Dali::ApplicationExtensions *)jarg1;
53207   {
53208     try {
53209       delete arg1;
53210     } catch (std::out_of_range& e) {
53211       {
53212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53213       };
53214     } catch (std::exception& e) {
53215       {
53216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53217       };
53218     } catch (...) {
53219       {
53220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53221       };
53222     }
53223   }
53224 }
53225
53226
53227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
53228   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53229
53230   arg1 = (Dali::ApplicationExtensions *)jarg1;
53231   {
53232     try {
53233       (arg1)->Init();
53234     } catch (std::out_of_range& e) {
53235       {
53236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53237       };
53238     } catch (std::exception& e) {
53239       {
53240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53241       };
53242     } catch (...) {
53243       {
53244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53245       };
53246     }
53247   }
53248 }
53249
53250
53251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
53252   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53253
53254   arg1 = (Dali::ApplicationExtensions *)jarg1;
53255   {
53256     try {
53257       (arg1)->Terminate();
53258     } catch (std::out_of_range& e) {
53259       {
53260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53261       };
53262     } catch (std::exception& e) {
53263       {
53264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53265       };
53266     } catch (...) {
53267       {
53268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53269       };
53270     }
53271   }
53272 }
53273
53274
53275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
53276   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53277
53278   arg1 = (Dali::ApplicationExtensions *)jarg1;
53279   {
53280     try {
53281       (arg1)->Pause();
53282     } catch (std::out_of_range& e) {
53283       {
53284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53285       };
53286     } catch (std::exception& e) {
53287       {
53288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53289       };
53290     } catch (...) {
53291       {
53292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53293       };
53294     }
53295   }
53296 }
53297
53298
53299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
53300   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53301
53302   arg1 = (Dali::ApplicationExtensions *)jarg1;
53303   {
53304     try {
53305       (arg1)->Resume();
53306     } catch (std::out_of_range& e) {
53307       {
53308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53309       };
53310     } catch (std::exception& e) {
53311       {
53312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53313       };
53314     } catch (...) {
53315       {
53316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53317       };
53318     }
53319   }
53320 }
53321
53322
53323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
53324   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53325
53326   arg1 = (Dali::ApplicationExtensions *)jarg1;
53327   {
53328     try {
53329       (arg1)->LanguageChange();
53330     } catch (std::out_of_range& e) {
53331       {
53332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53333       };
53334     } catch (std::exception& e) {
53335       {
53336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53337       };
53338     } catch (...) {
53339       {
53340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53341       };
53342     }
53343   }
53344 }
53345
53346
53347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
53348   void * jresult ;
53349   Dali::PositionSize arg1 ;
53350   std::string *arg2 = 0 ;
53351   bool arg3 ;
53352   Dali::PositionSize *argp1 ;
53353   Dali::Window result;
53354
53355   argp1 = (Dali::PositionSize *)jarg1;
53356   if (!argp1) {
53357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53358     return 0;
53359   }
53360   arg1 = *argp1;
53361   if (!jarg2) {
53362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53363     return 0;
53364   }
53365   std::string arg2_str(jarg2);
53366   arg2 = &arg2_str;
53367   arg3 = jarg3 ? true : false;
53368   {
53369     try {
53370       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
53371     } catch (std::out_of_range& e) {
53372       {
53373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53374       };
53375     } catch (std::exception& e) {
53376       {
53377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53378       };
53379     } catch (...) {
53380       {
53381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53382       };
53383     }
53384   }
53385   jresult = new Dali::Window((const Dali::Window &)result);
53386
53387   //argout typemap for const std::string&
53388
53389   return jresult;
53390 }
53391
53392
53393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
53394   void * jresult ;
53395   Dali::PositionSize arg1 ;
53396   std::string *arg2 = 0 ;
53397   Dali::PositionSize *argp1 ;
53398   Dali::Window result;
53399
53400   argp1 = (Dali::PositionSize *)jarg1;
53401   if (!argp1) {
53402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53403     return 0;
53404   }
53405   arg1 = *argp1;
53406   if (!jarg2) {
53407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53408     return 0;
53409   }
53410   std::string arg2_str(jarg2);
53411   arg2 = &arg2_str;
53412   {
53413     try {
53414       result = Dali::Window::New(arg1,(std::string const &)*arg2);
53415     } catch (std::out_of_range& e) {
53416       {
53417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53418       };
53419     } catch (std::exception& e) {
53420       {
53421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53422       };
53423     } catch (...) {
53424       {
53425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53426       };
53427     }
53428   }
53429   jresult = new Dali::Window((const Dali::Window &)result);
53430
53431   //argout typemap for const std::string&
53432
53433   return jresult;
53434 }
53435
53436
53437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
53438   void * jresult ;
53439   Dali::PositionSize arg1 ;
53440   std::string *arg2 = 0 ;
53441   std::string *arg3 = 0 ;
53442   bool arg4 ;
53443   Dali::PositionSize *argp1 ;
53444   Dali::Window result;
53445
53446   argp1 = (Dali::PositionSize *)jarg1;
53447   if (!argp1) {
53448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53449     return 0;
53450   }
53451   arg1 = *argp1;
53452   if (!jarg2) {
53453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53454     return 0;
53455   }
53456   std::string arg2_str(jarg2);
53457   arg2 = &arg2_str;
53458   if (!jarg3) {
53459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53460     return 0;
53461   }
53462   std::string arg3_str(jarg3);
53463   arg3 = &arg3_str;
53464   arg4 = jarg4 ? true : false;
53465   {
53466     try {
53467       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
53468     } catch (std::out_of_range& e) {
53469       {
53470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53471       };
53472     } catch (std::exception& e) {
53473       {
53474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53475       };
53476     } catch (...) {
53477       {
53478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53479       };
53480     }
53481   }
53482   jresult = new Dali::Window((const Dali::Window &)result);
53483
53484   //argout typemap for const std::string&
53485
53486
53487   //argout typemap for const std::string&
53488
53489   return jresult;
53490 }
53491
53492
53493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
53494   void * jresult ;
53495   Dali::PositionSize arg1 ;
53496   std::string *arg2 = 0 ;
53497   std::string *arg3 = 0 ;
53498   Dali::PositionSize *argp1 ;
53499   Dali::Window result;
53500
53501   argp1 = (Dali::PositionSize *)jarg1;
53502   if (!argp1) {
53503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53504     return 0;
53505   }
53506   arg1 = *argp1;
53507   if (!jarg2) {
53508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53509     return 0;
53510   }
53511   std::string arg2_str(jarg2);
53512   arg2 = &arg2_str;
53513   if (!jarg3) {
53514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53515     return 0;
53516   }
53517   std::string arg3_str(jarg3);
53518   arg3 = &arg3_str;
53519   {
53520     try {
53521       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
53522     } catch (std::out_of_range& e) {
53523       {
53524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53525       };
53526     } catch (std::exception& e) {
53527       {
53528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53529       };
53530     } catch (...) {
53531       {
53532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53533       };
53534     }
53535   }
53536   jresult = new Dali::Window((const Dali::Window &)result);
53537
53538   //argout typemap for const std::string&
53539
53540
53541   //argout typemap for const std::string&
53542
53543   return jresult;
53544 }
53545
53546
53547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
53548   void * jresult ;
53549   Dali::Window *result = 0 ;
53550
53551   {
53552     try {
53553       result = (Dali::Window *)new Dali::Window();
53554     } catch (std::out_of_range& e) {
53555       {
53556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53557       };
53558     } catch (std::exception& e) {
53559       {
53560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53561       };
53562     } catch (...) {
53563       {
53564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53565       };
53566     }
53567   }
53568   jresult = (void *)result;
53569   return jresult;
53570 }
53571
53572
53573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
53574   Dali::Window *arg1 = (Dali::Window *) 0 ;
53575
53576   arg1 = (Dali::Window *)jarg1;
53577   {
53578     try {
53579       delete arg1;
53580     } catch (std::out_of_range& e) {
53581       {
53582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53583       };
53584     } catch (std::exception& e) {
53585       {
53586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53587       };
53588     } catch (...) {
53589       {
53590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53591       };
53592     }
53593   }
53594 }
53595
53596
53597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) {
53598   void * jresult ;
53599   Dali::Window *arg1 = 0 ;
53600   Dali::Window *result = 0 ;
53601
53602   arg1 = (Dali::Window *)jarg1;
53603   if (!arg1) {
53604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53605     return 0;
53606   }
53607   {
53608     try {
53609       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
53610     } catch (std::out_of_range& e) {
53611       {
53612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53613       };
53614     } catch (std::exception& e) {
53615       {
53616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53617       };
53618     } catch (...) {
53619       {
53620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53621       };
53622     }
53623   }
53624   jresult = (void *)result;
53625   return jresult;
53626 }
53627
53628
53629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
53630   void * jresult ;
53631   Dali::Window *arg1 = (Dali::Window *) 0 ;
53632   Dali::Window *arg2 = 0 ;
53633   Dali::Window *result = 0 ;
53634
53635   arg1 = (Dali::Window *)jarg1;
53636   arg2 = (Dali::Window *)jarg2;
53637   if (!arg2) {
53638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53639     return 0;
53640   }
53641   {
53642     try {
53643       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
53644     } catch (std::out_of_range& e) {
53645       {
53646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53647       };
53648     } catch (std::exception& e) {
53649       {
53650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53651       };
53652     } catch (...) {
53653       {
53654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53655       };
53656     }
53657   }
53658   jresult = (void *)result;
53659   return jresult;
53660 }
53661
53662
53663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ShowIndicator(void * jarg1, int jarg2) {
53664   Dali::Window *arg1 = (Dali::Window *) 0 ;
53665   Dali::Window::IndicatorVisibleMode arg2 ;
53666
53667   arg1 = (Dali::Window *)jarg1;
53668   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
53669   {
53670     try {
53671       (arg1)->ShowIndicator(arg2);
53672     } catch (std::out_of_range& e) {
53673       {
53674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53675       };
53676     } catch (std::exception& e) {
53677       {
53678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53679       };
53680     } catch (...) {
53681       {
53682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53683       };
53684     }
53685   }
53686 }
53687
53688
53689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
53690   Dali::Window *arg1 = (Dali::Window *) 0 ;
53691   Dali::Window::IndicatorBgOpacity arg2 ;
53692
53693   arg1 = (Dali::Window *)jarg1;
53694   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
53695   {
53696     try {
53697       (arg1)->SetIndicatorBgOpacity(arg2);
53698     } catch (std::out_of_range& e) {
53699       {
53700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53701       };
53702     } catch (std::exception& e) {
53703       {
53704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53705       };
53706     } catch (...) {
53707       {
53708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53709       };
53710     }
53711   }
53712 }
53713
53714
53715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RotateIndicator(void * jarg1, int jarg2) {
53716   Dali::Window *arg1 = (Dali::Window *) 0 ;
53717   Dali::Window::WindowOrientation arg2 ;
53718
53719   arg1 = (Dali::Window *)jarg1;
53720   arg2 = (Dali::Window::WindowOrientation)jarg2;
53721   {
53722     try {
53723       (arg1)->RotateIndicator(arg2);
53724     } catch (std::out_of_range& e) {
53725       {
53726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53727       };
53728     } catch (std::exception& e) {
53729       {
53730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53731       };
53732     } catch (...) {
53733       {
53734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53735       };
53736     }
53737   }
53738 }
53739
53740
53741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
53742   Dali::Window *arg1 = (Dali::Window *) 0 ;
53743   std::string arg2 ;
53744   std::string arg3 ;
53745
53746   arg1 = (Dali::Window *)jarg1;
53747   if (!jarg2) {
53748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53749     return ;
53750   }
53751   (&arg2)->assign(jarg2);
53752   if (!jarg3) {
53753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53754     return ;
53755   }
53756   (&arg3)->assign(jarg3);
53757   {
53758     try {
53759       (arg1)->SetClass(arg2,arg3);
53760     } catch (std::out_of_range& e) {
53761       {
53762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53763       };
53764     } catch (std::exception& e) {
53765       {
53766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53767       };
53768     } catch (...) {
53769       {
53770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53771       };
53772     }
53773   }
53774 }
53775
53776
53777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
53778   Dali::Window *arg1 = (Dali::Window *) 0 ;
53779
53780   arg1 = (Dali::Window *)jarg1;
53781   {
53782     try {
53783       (arg1)->Raise();
53784     } catch (std::out_of_range& e) {
53785       {
53786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53787       };
53788     } catch (std::exception& e) {
53789       {
53790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53791       };
53792     } catch (...) {
53793       {
53794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53795       };
53796     }
53797   }
53798 }
53799
53800
53801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) {
53802   Dali::Window *arg1 = (Dali::Window *) 0 ;
53803
53804   arg1 = (Dali::Window *)jarg1;
53805   {
53806     try {
53807       (arg1)->Lower();
53808     } catch (std::out_of_range& e) {
53809       {
53810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53811       };
53812     } catch (std::exception& e) {
53813       {
53814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53815       };
53816     } catch (...) {
53817       {
53818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53819       };
53820     }
53821   }
53822 }
53823
53824
53825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
53826   Dali::Window *arg1 = (Dali::Window *) 0 ;
53827
53828   arg1 = (Dali::Window *)jarg1;
53829   {
53830     try {
53831       (arg1)->Activate();
53832     } catch (std::out_of_range& e) {
53833       {
53834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53835       };
53836     } catch (std::exception& e) {
53837       {
53838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53839       };
53840     } catch (...) {
53841       {
53842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53843       };
53844     }
53845   }
53846 }
53847
53848
53849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
53850   Dali::Window *arg1 = (Dali::Window *) 0 ;
53851   Dali::Window::WindowOrientation arg2 ;
53852
53853   arg1 = (Dali::Window *)jarg1;
53854   arg2 = (Dali::Window::WindowOrientation)jarg2;
53855   {
53856     try {
53857       (arg1)->AddAvailableOrientation(arg2);
53858     } catch (std::out_of_range& e) {
53859       {
53860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53861       };
53862     } catch (std::exception& e) {
53863       {
53864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53865       };
53866     } catch (...) {
53867       {
53868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53869       };
53870     }
53871   }
53872 }
53873
53874
53875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
53876   Dali::Window *arg1 = (Dali::Window *) 0 ;
53877   Dali::Window::WindowOrientation arg2 ;
53878
53879   arg1 = (Dali::Window *)jarg1;
53880   arg2 = (Dali::Window::WindowOrientation)jarg2;
53881   {
53882     try {
53883       (arg1)->RemoveAvailableOrientation(arg2);
53884     } catch (std::out_of_range& e) {
53885       {
53886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53887       };
53888     } catch (std::exception& e) {
53889       {
53890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53891       };
53892     } catch (...) {
53893       {
53894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53895       };
53896     }
53897   }
53898 }
53899
53900
53901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
53902   Dali::Window *arg1 = (Dali::Window *) 0 ;
53903   Dali::Window::WindowOrientation arg2 ;
53904
53905   arg1 = (Dali::Window *)jarg1;
53906   arg2 = (Dali::Window::WindowOrientation)jarg2;
53907   {
53908     try {
53909       (arg1)->SetPreferredOrientation(arg2);
53910     } catch (std::out_of_range& e) {
53911       {
53912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53913       };
53914     } catch (std::exception& e) {
53915       {
53916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53917       };
53918     } catch (...) {
53919       {
53920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53921       };
53922     }
53923   }
53924 }
53925
53926
53927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
53928   int jresult ;
53929   Dali::Window *arg1 = (Dali::Window *) 0 ;
53930   Dali::Window::WindowOrientation result;
53931
53932   arg1 = (Dali::Window *)jarg1;
53933   {
53934     try {
53935       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
53936     } catch (std::out_of_range& e) {
53937       {
53938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53939       };
53940     } catch (std::exception& e) {
53941       {
53942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53943       };
53944     } catch (...) {
53945       {
53946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53947       };
53948     }
53949   }
53950   jresult = (int)result;
53951   return jresult;
53952 }
53953
53954
53955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetDragAndDropDetector(void * jarg1) {
53956   void * jresult ;
53957   Dali::Window *arg1 = (Dali::Window *) 0 ;
53958   Dali::DragAndDropDetector result;
53959
53960   arg1 = (Dali::Window *)jarg1;
53961   {
53962     try {
53963       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
53964     } catch (std::out_of_range& e) {
53965       {
53966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53967       };
53968     } catch (std::exception& e) {
53969       {
53970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53971       };
53972     } catch (...) {
53973       {
53974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53975       };
53976     }
53977   }
53978   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
53979   return jresult;
53980 }
53981
53982
53983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
53984   void * jresult ;
53985   Dali::Window *arg1 = (Dali::Window *) 0 ;
53986   Dali::Any result;
53987
53988   arg1 = (Dali::Window *)jarg1;
53989   {
53990     try {
53991       result = ((Dali::Window const *)arg1)->GetNativeHandle();
53992     } catch (std::out_of_range& e) {
53993       {
53994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53995       };
53996     } catch (std::exception& e) {
53997       {
53998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53999       };
54000     } catch (...) {
54001       {
54002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54003       };
54004     }
54005   }
54006   jresult = new Dali::Any((const Dali::Any &)result);
54007   return jresult;
54008 }
54009
54010
54011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FocusChangedSignal(void * jarg1) {
54012   void * jresult ;
54013   Dali::Window arg1 ;
54014   Dali::Window *argp1 ;
54015   Dali::DevelWindow::FocusSignalType *result = 0 ;
54016
54017   argp1 = (Dali::Window *)jarg1;
54018   if (!argp1) {
54019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54020     return 0;
54021   }
54022   arg1 = *argp1;
54023   {
54024     try {
54025       result = (Dali::DevelWindow::FocusSignalType *) &Dali::DevelWindow::FocusChangedSignal(arg1);
54026     } catch (std::out_of_range& e) {
54027       {
54028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54029       };
54030     } catch (std::exception& e) {
54031       {
54032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54033       };
54034     } catch (...) {
54035       {
54036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54037       };
54038     }
54039   }
54040   jresult = (void *)result;
54041   return jresult;
54042 }
54043
54044
54045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetAcceptFocus(void * jarg1, unsigned int jarg2) {
54046   Dali::Window arg1 ;
54047   bool arg2 ;
54048   Dali::Window *argp1 ;
54049
54050   argp1 = (Dali::Window *)jarg1;
54051   if (!argp1) {
54052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54053     return ;
54054   }
54055   arg1 = *argp1;
54056   arg2 = jarg2 ? true : false;
54057   {
54058     try {
54059       Dali::DevelWindow::SetAcceptFocus(arg1,arg2);
54060     } catch (std::out_of_range& e) {
54061       {
54062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54063       };
54064     } catch (std::exception& e) {
54065       {
54066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54067       };
54068     } catch (...) {
54069       {
54070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54071       };
54072     }
54073   }
54074 }
54075
54076
54077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsFocusAcceptable(void * jarg1) {
54078   unsigned int jresult ;
54079   Dali::Window arg1 ;
54080   Dali::Window *argp1 ;
54081   bool result;
54082
54083   argp1 = (Dali::Window *)jarg1;
54084   if (!argp1) {
54085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54086     return 0;
54087   }
54088   arg1 = *argp1;
54089   {
54090     try {
54091       result = (bool)Dali::DevelWindow::IsFocusAcceptable(arg1);
54092     } catch (std::out_of_range& e) {
54093       {
54094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54095       };
54096     } catch (std::exception& e) {
54097       {
54098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54099       };
54100     } catch (...) {
54101       {
54102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54103       };
54104     }
54105   }
54106   jresult = result;
54107   return jresult;
54108 }
54109
54110
54111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Show(void * jarg1) {
54112   Dali::Window arg1 ;
54113   Dali::Window *argp1 ;
54114
54115   argp1 = (Dali::Window *)jarg1;
54116   if (!argp1) {
54117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54118     return ;
54119   }
54120   arg1 = *argp1;
54121   {
54122     try {
54123       Dali::DevelWindow::Show(arg1);
54124     } catch (std::out_of_range& e) {
54125       {
54126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54127       };
54128     } catch (std::exception& e) {
54129       {
54130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54131       };
54132     } catch (...) {
54133       {
54134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54135       };
54136     }
54137   }
54138 }
54139
54140
54141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hide(void * jarg1) {
54142   Dali::Window arg1 ;
54143   Dali::Window *argp1 ;
54144
54145   argp1 = (Dali::Window *)jarg1;
54146   if (!argp1) {
54147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54148     return ;
54149   }
54150   arg1 = *argp1;
54151   {
54152     try {
54153       Dali::DevelWindow::Hide(arg1);
54154     } catch (std::out_of_range& e) {
54155       {
54156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54157       };
54158     } catch (std::exception& e) {
54159       {
54160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54161       };
54162     } catch (...) {
54163       {
54164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54165       };
54166     }
54167   }
54168 }
54169
54170
54171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) {
54172   unsigned int jresult ;
54173   Dali::Window arg1 ;
54174   Dali::Window *argp1 ;
54175   bool result;
54176
54177   argp1 = (Dali::Window *)jarg1;
54178   if (!argp1) {
54179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54180     return 0;
54181   }
54182   arg1 = *argp1;
54183   {
54184     try {
54185       result = (bool)Dali::DevelWindow::IsVisible(arg1);
54186     } catch (std::out_of_range& e) {
54187       {
54188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54189       };
54190     } catch (std::exception& e) {
54191       {
54192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54193       };
54194     } catch (...) {
54195       {
54196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54197       };
54198     }
54199   }
54200   jresult = result;
54201   return jresult;
54202 }
54203
54204
54205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
54206   void * jresult ;
54207   Dali::Application result;
54208
54209   {
54210     try {
54211       result = Dali::Application::New();
54212     } catch (std::out_of_range& e) {
54213       {
54214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54215       };
54216     } catch (std::exception& e) {
54217       {
54218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54219       };
54220     } catch (...) {
54221       {
54222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54223       };
54224     }
54225   }
54226   jresult = new Dali::Application((const Dali::Application &)result);
54227   return jresult;
54228 }
54229
54230
54231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
54232   void * jresult ;
54233   int *arg1 = (int *) 0 ;
54234   char ***arg2 ;
54235   Dali::Application result;
54236
54237   {
54238     // Todo generate argv data from the C# args
54239     char **array;         // two dimensional array
54240     int numStrings = 1;     // number of strings
54241     int stringLength = 30;      // max string length.
54242     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54243     argV = array;
54244
54245     // allocate the string data
54246     for( int i=0; i < numStrings; i++)
54247     {
54248       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54249     }
54250     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54251
54252     strcpy( array[0], "dali-csharp-app");
54253
54254     arg1 = &argC;
54255     arg2 = &argV;
54256   }
54257   {
54258     try {
54259       result = Dali::Application::New(arg1,arg2);
54260     } catch (std::out_of_range& e) {
54261       {
54262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54263       };
54264     } catch (std::exception& e) {
54265       {
54266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54267       };
54268     } catch (...) {
54269       {
54270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54271       };
54272     }
54273   }
54274   jresult = new Dali::Application((const Dali::Application &)result);
54275   return jresult;
54276 }
54277
54278
54279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
54280   void * jresult ;
54281   int *arg1 = (int *) 0 ;
54282   char ***arg2 ;
54283   std::string *arg3 = 0 ;
54284   Dali::Application result;
54285
54286   {
54287     // Todo generate argv data from the C# args
54288     char **array;         // two dimensional array
54289     int numStrings = 1;     // number of strings
54290     int stringLength = 30;      // max string length.
54291     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54292     argV = array;
54293
54294     // allocate the string data
54295     for( int i=0; i < numStrings; i++)
54296     {
54297       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54298     }
54299     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54300
54301     strcpy( array[0], "dali-csharp-app");
54302
54303     arg1 = &argC;
54304     arg2 = &argV;
54305   }
54306   if (!jarg3) {
54307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54308     return 0;
54309   }
54310   std::string arg3_str(jarg3);
54311   arg3 = &arg3_str;
54312   {
54313     try {
54314       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
54315     } catch (std::out_of_range& e) {
54316       {
54317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54318       };
54319     } catch (std::exception& e) {
54320       {
54321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54322       };
54323     } catch (...) {
54324       {
54325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54326       };
54327     }
54328   }
54329   jresult = new Dali::Application((const Dali::Application &)result);
54330
54331   //argout typemap for const std::string&
54332
54333   return jresult;
54334 }
54335
54336
54337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
54338   void * jresult ;
54339   int *arg1 = (int *) 0 ;
54340   char ***arg2 ;
54341   std::string *arg3 = 0 ;
54342   Dali::Application::WINDOW_MODE arg4 ;
54343   Dali::Application result;
54344
54345   {
54346     // Todo generate argv data from the C# args
54347     char **array;         // two dimensional array
54348     int numStrings = 1;     // number of strings
54349     int stringLength = 30;      // max string length.
54350     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54351     argV = array;
54352
54353     // allocate the string data
54354     for( int i=0; i < numStrings; i++)
54355     {
54356       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54357     }
54358     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54359
54360     strcpy( array[0], "dali-csharp-app");
54361
54362     arg1 = &argC;
54363     arg2 = &argV;
54364   }
54365   if (!jarg3) {
54366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54367     return 0;
54368   }
54369   std::string arg3_str(jarg3);
54370   arg3 = &arg3_str;
54371   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
54372   {
54373     try {
54374       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
54375     } catch (std::out_of_range& e) {
54376       {
54377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54378       };
54379     } catch (std::exception& e) {
54380       {
54381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54382       };
54383     } catch (...) {
54384       {
54385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54386       };
54387     }
54388   }
54389   jresult = new Dali::Application((const Dali::Application &)result);
54390
54391   //argout typemap for const std::string&
54392
54393   return jresult;
54394 }
54395
54396
54397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
54398   void * jresult ;
54399   Dali::Application *result = 0 ;
54400
54401   {
54402     try {
54403       result = (Dali::Application *)new Dali::Application();
54404     } catch (std::out_of_range& e) {
54405       {
54406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54407       };
54408     } catch (std::exception& e) {
54409       {
54410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54411       };
54412     } catch (...) {
54413       {
54414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54415       };
54416     }
54417   }
54418   jresult = (void *)result;
54419   return jresult;
54420 }
54421
54422
54423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
54424   void * jresult ;
54425   Dali::Application *arg1 = 0 ;
54426   Dali::Application *result = 0 ;
54427
54428   arg1 = (Dali::Application *)jarg1;
54429   if (!arg1) {
54430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
54431     return 0;
54432   }
54433   {
54434     try {
54435       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
54436     } catch (std::out_of_range& e) {
54437       {
54438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54439       };
54440     } catch (std::exception& e) {
54441       {
54442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54443       };
54444     } catch (...) {
54445       {
54446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54447       };
54448     }
54449   }
54450   jresult = (void *)result;
54451   return jresult;
54452 }
54453
54454
54455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
54456   void * jresult ;
54457   Dali::Application *arg1 = (Dali::Application *) 0 ;
54458   Dali::Application *arg2 = 0 ;
54459   Dali::Application *result = 0 ;
54460
54461   arg1 = (Dali::Application *)jarg1;
54462   arg2 = (Dali::Application *)jarg2;
54463   if (!arg2) {
54464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
54465     return 0;
54466   }
54467   {
54468     try {
54469       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*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 = (void *)result;
54485   return jresult;
54486 }
54487
54488
54489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
54490   Dali::Application *arg1 = (Dali::Application *) 0 ;
54491
54492   arg1 = (Dali::Application *)jarg1;
54493   {
54494     try {
54495       delete arg1;
54496     } catch (std::out_of_range& e) {
54497       {
54498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54499       };
54500     } catch (std::exception& e) {
54501       {
54502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54503       };
54504     } catch (...) {
54505       {
54506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54507       };
54508     }
54509   }
54510 }
54511
54512
54513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
54514   Dali::Application *arg1 = (Dali::Application *) 0 ;
54515
54516   arg1 = (Dali::Application *)jarg1;
54517   {
54518     try {
54519       (arg1)->MainLoop();
54520     } catch (std::out_of_range& e) {
54521       {
54522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54523       };
54524     } catch (std::exception& e) {
54525       {
54526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54527       };
54528     } catch (...) {
54529       {
54530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54531       };
54532     }
54533   }
54534 }
54535
54536
54537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
54538   Dali::Application *arg1 = (Dali::Application *) 0 ;
54539   Configuration::ContextLoss arg2 ;
54540   Configuration::ContextLoss *argp2 ;
54541
54542   arg1 = (Dali::Application *)jarg1;
54543   argp2 = (Configuration::ContextLoss *)jarg2;
54544   if (!argp2) {
54545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
54546     return ;
54547   }
54548   arg2 = *argp2;
54549   {
54550     try {
54551       (arg1)->MainLoop(arg2);
54552     } catch (std::out_of_range& e) {
54553       {
54554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54555       };
54556     } catch (std::exception& e) {
54557       {
54558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54559       };
54560     } catch (...) {
54561       {
54562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54563       };
54564     }
54565   }
54566 }
54567
54568
54569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
54570   Dali::Application *arg1 = (Dali::Application *) 0 ;
54571
54572   arg1 = (Dali::Application *)jarg1;
54573   {
54574     try {
54575       (arg1)->Lower();
54576     } catch (std::out_of_range& e) {
54577       {
54578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54579       };
54580     } catch (std::exception& e) {
54581       {
54582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54583       };
54584     } catch (...) {
54585       {
54586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54587       };
54588     }
54589   }
54590 }
54591
54592
54593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
54594   Dali::Application *arg1 = (Dali::Application *) 0 ;
54595
54596   arg1 = (Dali::Application *)jarg1;
54597   {
54598     try {
54599       (arg1)->Quit();
54600     } catch (std::out_of_range& e) {
54601       {
54602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54603       };
54604     } catch (std::exception& e) {
54605       {
54606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54607       };
54608     } catch (...) {
54609       {
54610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54611       };
54612     }
54613   }
54614 }
54615
54616
54617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
54618   unsigned int jresult ;
54619   Dali::Application *arg1 = (Dali::Application *) 0 ;
54620   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
54621   bool result;
54622
54623   arg1 = (Dali::Application *)jarg1;
54624   arg2 = (Dali::CallbackBase *)jarg2;
54625   {
54626     try {
54627       result = (bool)(arg1)->AddIdle(arg2);
54628     } catch (std::out_of_range& e) {
54629       {
54630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54631       };
54632     } catch (std::exception& e) {
54633       {
54634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54635       };
54636     } catch (...) {
54637       {
54638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54639       };
54640     }
54641   }
54642   jresult = result;
54643   return jresult;
54644 }
54645
54646
54647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
54648   void * jresult ;
54649   Dali::Application *arg1 = (Dali::Application *) 0 ;
54650   Dali::Window result;
54651
54652   arg1 = (Dali::Application *)jarg1;
54653   {
54654     try {
54655       result = (arg1)->GetWindow();
54656     } catch (std::out_of_range& e) {
54657       {
54658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54659       };
54660     } catch (std::exception& e) {
54661       {
54662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54663       };
54664     } catch (...) {
54665       {
54666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54667       };
54668     }
54669   }
54670   jresult = new Dali::Window((const Dali::Window &)result);
54671   return jresult;
54672 }
54673
54674
54675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
54676   Dali::Application *arg1 = (Dali::Application *) 0 ;
54677   Dali::PositionSize arg2 ;
54678   std::string *arg3 = 0 ;
54679   Dali::PositionSize *argp2 ;
54680
54681   arg1 = (Dali::Application *)jarg1;
54682   argp2 = (Dali::PositionSize *)jarg2;
54683   if (!argp2) {
54684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54685     return ;
54686   }
54687   arg2 = *argp2;
54688   if (!jarg3) {
54689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54690     return ;
54691   }
54692   std::string arg3_str(jarg3);
54693   arg3 = &arg3_str;
54694   {
54695     try {
54696       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
54697     } catch (std::out_of_range& e) {
54698       {
54699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54700       };
54701     } catch (std::exception& e) {
54702       {
54703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54704       };
54705     } catch (...) {
54706       {
54707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54708       };
54709     }
54710   }
54711
54712   //argout typemap for const std::string&
54713
54714 }
54715
54716
54717 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
54718   char * jresult ;
54719   std::string result;
54720
54721   {
54722     try {
54723       result = Dali::Application::GetResourcePath();
54724     } catch (std::out_of_range& e) {
54725       {
54726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54727       };
54728     } catch (std::exception& e) {
54729       {
54730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54731       };
54732     } catch (...) {
54733       {
54734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54735       };
54736     }
54737   }
54738   jresult = SWIG_csharp_string_callback((&result)->c_str());
54739   return jresult;
54740 }
54741
54742
54743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
54744   Dali::Application *arg1 = (Dali::Application *) 0 ;
54745   Dali::ViewMode arg2 ;
54746
54747   arg1 = (Dali::Application *)jarg1;
54748   arg2 = (Dali::ViewMode)jarg2;
54749   {
54750     try {
54751       (arg1)->SetViewMode(arg2);
54752     } catch (std::out_of_range& e) {
54753       {
54754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54755       };
54756     } catch (std::exception& e) {
54757       {
54758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54759       };
54760     } catch (...) {
54761       {
54762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54763       };
54764     }
54765   }
54766 }
54767
54768
54769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
54770   int jresult ;
54771   Dali::Application *arg1 = (Dali::Application *) 0 ;
54772   Dali::ViewMode result;
54773
54774   arg1 = (Dali::Application *)jarg1;
54775   {
54776     try {
54777       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
54778     } catch (std::out_of_range& e) {
54779       {
54780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54781       };
54782     } catch (std::exception& e) {
54783       {
54784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54785       };
54786     } catch (...) {
54787       {
54788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54789       };
54790     }
54791   }
54792   jresult = (int)result;
54793   return jresult;
54794 }
54795
54796
54797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
54798   Dali::Application *arg1 = (Dali::Application *) 0 ;
54799   float arg2 ;
54800
54801   arg1 = (Dali::Application *)jarg1;
54802   arg2 = (float)jarg2;
54803   {
54804     try {
54805       (arg1)->SetStereoBase(arg2);
54806     } catch (std::out_of_range& e) {
54807       {
54808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54809       };
54810     } catch (std::exception& e) {
54811       {
54812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54813       };
54814     } catch (...) {
54815       {
54816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54817       };
54818     }
54819   }
54820 }
54821
54822
54823 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
54824   float jresult ;
54825   Dali::Application *arg1 = (Dali::Application *) 0 ;
54826   float result;
54827
54828   arg1 = (Dali::Application *)jarg1;
54829   {
54830     try {
54831       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
54832     } catch (std::out_of_range& e) {
54833       {
54834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54835       };
54836     } catch (std::exception& e) {
54837       {
54838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54839       };
54840     } catch (...) {
54841       {
54842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54843       };
54844     }
54845   }
54846   jresult = result;
54847   return jresult;
54848 }
54849
54850
54851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
54852   void * jresult ;
54853   Dali::Application *arg1 = (Dali::Application *) 0 ;
54854   Dali::Application::AppSignalType *result = 0 ;
54855
54856   arg1 = (Dali::Application *)jarg1;
54857   {
54858     try {
54859       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
54860     } catch (std::out_of_range& e) {
54861       {
54862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54863       };
54864     } catch (std::exception& e) {
54865       {
54866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54867       };
54868     } catch (...) {
54869       {
54870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54871       };
54872     }
54873   }
54874   jresult = (void *)result;
54875   return jresult;
54876 }
54877
54878
54879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
54880   void * jresult ;
54881   Dali::Application *arg1 = (Dali::Application *) 0 ;
54882   Dali::Application::AppSignalType *result = 0 ;
54883
54884   arg1 = (Dali::Application *)jarg1;
54885   {
54886     try {
54887       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
54888     } catch (std::out_of_range& e) {
54889       {
54890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54891       };
54892     } catch (std::exception& e) {
54893       {
54894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54895       };
54896     } catch (...) {
54897       {
54898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54899       };
54900     }
54901   }
54902   jresult = (void *)result;
54903   return jresult;
54904 }
54905
54906
54907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
54908   void * jresult ;
54909   Dali::Application *arg1 = (Dali::Application *) 0 ;
54910   Dali::Application::AppSignalType *result = 0 ;
54911
54912   arg1 = (Dali::Application *)jarg1;
54913   {
54914     try {
54915       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
54916     } catch (std::out_of_range& e) {
54917       {
54918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54919       };
54920     } catch (std::exception& e) {
54921       {
54922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54923       };
54924     } catch (...) {
54925       {
54926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54927       };
54928     }
54929   }
54930   jresult = (void *)result;
54931   return jresult;
54932 }
54933
54934
54935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
54936   void * jresult ;
54937   Dali::Application *arg1 = (Dali::Application *) 0 ;
54938   Dali::Application::AppSignalType *result = 0 ;
54939
54940   arg1 = (Dali::Application *)jarg1;
54941   {
54942     try {
54943       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
54944     } catch (std::out_of_range& e) {
54945       {
54946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54947       };
54948     } catch (std::exception& e) {
54949       {
54950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54951       };
54952     } catch (...) {
54953       {
54954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54955       };
54956     }
54957   }
54958   jresult = (void *)result;
54959   return jresult;
54960 }
54961
54962
54963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
54964   void * jresult ;
54965   Dali::Application *arg1 = (Dali::Application *) 0 ;
54966   Dali::Application::AppSignalType *result = 0 ;
54967
54968   arg1 = (Dali::Application *)jarg1;
54969   {
54970     try {
54971       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
54972     } catch (std::out_of_range& e) {
54973       {
54974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54975       };
54976     } catch (std::exception& e) {
54977       {
54978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54979       };
54980     } catch (...) {
54981       {
54982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54983       };
54984     }
54985   }
54986   jresult = (void *)result;
54987   return jresult;
54988 }
54989
54990
54991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
54992   void * jresult ;
54993   Dali::Application *arg1 = (Dali::Application *) 0 ;
54994   Dali::Application::AppSignalType *result = 0 ;
54995
54996   arg1 = (Dali::Application *)jarg1;
54997   {
54998     try {
54999       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
55000     } catch (std::out_of_range& e) {
55001       {
55002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55003       };
55004     } catch (std::exception& e) {
55005       {
55006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55007       };
55008     } catch (...) {
55009       {
55010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55011       };
55012     }
55013   }
55014   jresult = (void *)result;
55015   return jresult;
55016 }
55017
55018
55019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
55020   void * jresult ;
55021   Dali::Application *arg1 = (Dali::Application *) 0 ;
55022   Dali::Application::AppControlSignalType *result = 0 ;
55023
55024   arg1 = (Dali::Application *)jarg1;
55025   {
55026     try {
55027       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
55028     } catch (std::out_of_range& e) {
55029       {
55030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55031       };
55032     } catch (std::exception& e) {
55033       {
55034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55035       };
55036     } catch (...) {
55037       {
55038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55039       };
55040     }
55041   }
55042   jresult = (void *)result;
55043   return jresult;
55044 }
55045
55046
55047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
55048   void * jresult ;
55049   Dali::Application *arg1 = (Dali::Application *) 0 ;
55050   Dali::Application::AppSignalType *result = 0 ;
55051
55052   arg1 = (Dali::Application *)jarg1;
55053   {
55054     try {
55055       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
55056     } catch (std::out_of_range& e) {
55057       {
55058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55059       };
55060     } catch (std::exception& e) {
55061       {
55062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55063       };
55064     } catch (...) {
55065       {
55066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55067       };
55068     }
55069   }
55070   jresult = (void *)result;
55071   return jresult;
55072 }
55073
55074
55075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
55076   void * jresult ;
55077   Dali::Application *arg1 = (Dali::Application *) 0 ;
55078   Dali::Application::AppSignalType *result = 0 ;
55079
55080   arg1 = (Dali::Application *)jarg1;
55081   {
55082     try {
55083       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
55084     } catch (std::out_of_range& e) {
55085       {
55086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55087       };
55088     } catch (std::exception& e) {
55089       {
55090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55091       };
55092     } catch (...) {
55093       {
55094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55095       };
55096     }
55097   }
55098   jresult = (void *)result;
55099   return jresult;
55100 }
55101
55102
55103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
55104   void * jresult ;
55105   Dali::Application *arg1 = (Dali::Application *) 0 ;
55106   Dali::Application::AppSignalType *result = 0 ;
55107
55108   arg1 = (Dali::Application *)jarg1;
55109   {
55110     try {
55111       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
55112     } catch (std::out_of_range& e) {
55113       {
55114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55115       };
55116     } catch (std::exception& e) {
55117       {
55118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55119       };
55120     } catch (...) {
55121       {
55122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55123       };
55124     }
55125   }
55126   jresult = (void *)result;
55127   return jresult;
55128 }
55129
55130
55131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
55132   void * jresult ;
55133   Dali::Application *arg1 = (Dali::Application *) 0 ;
55134   Dali::Application::AppSignalType *result = 0 ;
55135
55136   arg1 = (Dali::Application *)jarg1;
55137   {
55138     try {
55139       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
55140     } catch (std::out_of_range& e) {
55141       {
55142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55143       };
55144     } catch (std::exception& e) {
55145       {
55146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55147       };
55148     } catch (...) {
55149       {
55150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55151       };
55152     }
55153   }
55154   jresult = (void *)result;
55155   return jresult;
55156 }
55157
55158
55159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
55160   unsigned int jresult ;
55161   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55162   bool result;
55163
55164   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55165   {
55166     try {
55167       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
55168     } catch (std::out_of_range& e) {
55169       {
55170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55171       };
55172     } catch (std::exception& e) {
55173       {
55174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55175       };
55176     } catch (...) {
55177       {
55178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55179       };
55180     }
55181   }
55182   jresult = result;
55183   return jresult;
55184 }
55185
55186
55187 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
55188   unsigned long jresult ;
55189   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55190   std::size_t result;
55191
55192   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55193   {
55194     try {
55195       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
55196     } catch (std::out_of_range& e) {
55197       {
55198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55199       };
55200     } catch (std::exception& e) {
55201       {
55202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55203       };
55204     } catch (...) {
55205       {
55206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55207       };
55208     }
55209   }
55210   jresult = (unsigned long)result;
55211   return jresult;
55212 }
55213
55214
55215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
55216   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55217   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
55218
55219   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55220   arg2 = (void (*)(Dali::Application &))jarg2;
55221   {
55222     try {
55223       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
55224     } catch (std::out_of_range& e) {
55225       {
55226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55227       };
55228     } catch (std::exception& e) {
55229       {
55230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55231       };
55232     } catch (...) {
55233       {
55234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55235       };
55236     }
55237   }
55238 }
55239
55240
55241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
55242   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55243   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
55244
55245   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55246   arg2 = (void (*)(Dali::Application &))jarg2;
55247   {
55248     try {
55249       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
55250     } catch (std::out_of_range& e) {
55251       {
55252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55253       };
55254     } catch (std::exception& e) {
55255       {
55256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55257       };
55258     } catch (...) {
55259       {
55260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55261       };
55262     }
55263   }
55264 }
55265
55266
55267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
55268   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55269   Dali::Application *arg2 = 0 ;
55270
55271   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55272   arg2 = (Dali::Application *)jarg2;
55273   if (!arg2) {
55274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
55275     return ;
55276   }
55277   {
55278     try {
55279       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(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_new_ApplicationSignal() {
55298   void * jresult ;
55299   Dali::Signal< void (Dali::Application &) > *result = 0 ;
55300
55301   {
55302     try {
55303       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
55304     } catch (std::out_of_range& e) {
55305       {
55306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55307       };
55308     } catch (std::exception& e) {
55309       {
55310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55311       };
55312     } catch (...) {
55313       {
55314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55315       };
55316     }
55317   }
55318   jresult = (void *)result;
55319   return jresult;
55320 }
55321
55322
55323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
55324   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55325
55326   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55327   {
55328     try {
55329       delete arg1;
55330     } catch (std::out_of_range& e) {
55331       {
55332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55333       };
55334     } catch (std::exception& e) {
55335       {
55336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55337       };
55338     } catch (...) {
55339       {
55340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55341       };
55342     }
55343   }
55344 }
55345
55346
55347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
55348   unsigned int jresult ;
55349   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55350   bool result;
55351
55352   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55353   {
55354     try {
55355       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
55356     } catch (std::out_of_range& e) {
55357       {
55358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55359       };
55360     } catch (std::exception& e) {
55361       {
55362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55363       };
55364     } catch (...) {
55365       {
55366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55367       };
55368     }
55369   }
55370   jresult = result;
55371   return jresult;
55372 }
55373
55374
55375 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
55376   unsigned long jresult ;
55377   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55378   std::size_t result;
55379
55380   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55381   {
55382     try {
55383       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
55384     } catch (std::out_of_range& e) {
55385       {
55386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55387       };
55388     } catch (std::exception& e) {
55389       {
55390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55391       };
55392     } catch (...) {
55393       {
55394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55395       };
55396     }
55397   }
55398   jresult = (unsigned long)result;
55399   return jresult;
55400 }
55401
55402
55403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
55404   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55405   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
55406
55407   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55408   arg2 = (void (*)(Dali::Application &,void *))jarg2;
55409   {
55410     try {
55411       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
55412     } catch (std::out_of_range& e) {
55413       {
55414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55415       };
55416     } catch (std::exception& e) {
55417       {
55418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55419       };
55420     } catch (...) {
55421       {
55422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55423       };
55424     }
55425   }
55426 }
55427
55428
55429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
55430   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55431   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
55432
55433   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55434   arg2 = (void (*)(Dali::Application &,void *))jarg2;
55435   {
55436     try {
55437       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
55438     } catch (std::out_of_range& e) {
55439       {
55440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55441       };
55442     } catch (std::exception& e) {
55443       {
55444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55445       };
55446     } catch (...) {
55447       {
55448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55449       };
55450     }
55451   }
55452 }
55453
55454
55455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55456   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55457   Dali::Application *arg2 = 0 ;
55458   void *arg3 = (void *) 0 ;
55459
55460   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55461   arg2 = (Dali::Application *)jarg2;
55462   if (!arg2) {
55463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
55464     return ;
55465   }
55466   arg3 = jarg3;
55467   {
55468     try {
55469       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
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 void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
55488   void * jresult ;
55489   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
55490
55491   {
55492     try {
55493       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
55494     } catch (std::out_of_range& e) {
55495       {
55496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55497       };
55498     } catch (std::exception& e) {
55499       {
55500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55501       };
55502     } catch (...) {
55503       {
55504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55505       };
55506     }
55507   }
55508   jresult = (void *)result;
55509   return jresult;
55510 }
55511
55512
55513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
55514   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55515
55516   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55517   {
55518     try {
55519       delete arg1;
55520     } catch (std::out_of_range& e) {
55521       {
55522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55523       };
55524     } catch (std::exception& e) {
55525       {
55526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55527       };
55528     } catch (...) {
55529       {
55530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55531       };
55532     }
55533   }
55534 }
55535
55536
55537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
55538   unsigned int jresult ;
55539   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55540   bool result;
55541
55542   arg1 = (Dali::Signal< bool () > *)jarg1;
55543   {
55544     try {
55545       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
55546     } catch (std::out_of_range& e) {
55547       {
55548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55549       };
55550     } catch (std::exception& e) {
55551       {
55552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55553       };
55554     } catch (...) {
55555       {
55556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55557       };
55558     }
55559   }
55560   jresult = result;
55561   return jresult;
55562 }
55563
55564
55565 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
55566   unsigned long jresult ;
55567   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55568   std::size_t result;
55569
55570   arg1 = (Dali::Signal< bool () > *)jarg1;
55571   {
55572     try {
55573       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< 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 = (unsigned long)result;
55589   return jresult;
55590 }
55591
55592
55593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
55594   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55595   bool (*arg2)() = (bool (*)()) 0 ;
55596
55597   arg1 = (Dali::Signal< bool () > *)jarg1;
55598   arg2 = (bool (*)())jarg2;
55599   {
55600     try {
55601       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
55602     } catch (std::out_of_range& e) {
55603       {
55604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55605       };
55606     } catch (std::exception& e) {
55607       {
55608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55609       };
55610     } catch (...) {
55611       {
55612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55613       };
55614     }
55615   }
55616 }
55617
55618
55619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55620   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55621   bool (*arg2)() = (bool (*)()) 0 ;
55622
55623   arg1 = (Dali::Signal< bool () > *)jarg1;
55624   arg2 = (bool (*)())jarg2;
55625   {
55626     try {
55627       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
55628     } catch (std::out_of_range& e) {
55629       {
55630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55631       };
55632     } catch (std::exception& e) {
55633       {
55634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55635       };
55636     } catch (...) {
55637       {
55638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55639       };
55640     }
55641   }
55642 }
55643
55644
55645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55646   unsigned int jresult ;
55647   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55648   bool result;
55649
55650   arg1 = (Dali::Signal< bool () > *)jarg1;
55651   {
55652     try {
55653       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55654     } catch (std::out_of_range& e) {
55655       {
55656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55657       };
55658     } catch (std::exception& e) {
55659       {
55660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55661       };
55662     } catch (...) {
55663       {
55664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55665       };
55666     }
55667   }
55668   jresult = result;
55669   return jresult;
55670 }
55671
55672
55673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55674   void * jresult ;
55675   Dali::Signal< bool () > *result = 0 ;
55676
55677   {
55678     try {
55679       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55680     } catch (std::out_of_range& e) {
55681       {
55682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55683       };
55684     } catch (std::exception& e) {
55685       {
55686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55687       };
55688     } catch (...) {
55689       {
55690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55691       };
55692     }
55693   }
55694   jresult = (void *)result;
55695   return jresult;
55696 }
55697
55698
55699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55700   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55701
55702   arg1 = (Dali::Signal< bool () > *)jarg1;
55703   {
55704     try {
55705       delete arg1;
55706     } catch (std::out_of_range& e) {
55707       {
55708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55709       };
55710     } catch (std::exception& e) {
55711       {
55712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55713       };
55714     } catch (...) {
55715       {
55716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55717       };
55718     }
55719   }
55720 }
55721
55722
55723
55724
55725
55726 //manual merge 2017-03-31
55727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) {
55728   unsigned int jresult ;
55729   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55730   bool result;
55731
55732   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55733   {
55734     try {
55735       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
55736     } catch (std::out_of_range& e) {
55737       {
55738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55739       };
55740     } catch (std::exception& e) {
55741       {
55742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55743       };
55744     } catch (...) {
55745       {
55746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55747       };
55748     }
55749   }
55750   jresult = result;
55751   return jresult;
55752 }
55753
55754
55755 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) {
55756   unsigned long jresult ;
55757   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55758   std::size_t result;
55759
55760   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55761   {
55762     try {
55763       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
55764     } catch (std::out_of_range& e) {
55765       {
55766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55767       };
55768     } catch (std::exception& e) {
55769       {
55770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55771       };
55772     } catch (...) {
55773       {
55774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55775       };
55776     }
55777   }
55778   jresult = (unsigned long)result;
55779   return jresult;
55780 }
55781
55782
55783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) {
55784   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55785   void (*arg2)(bool) = (void (*)(bool)) 0 ;
55786
55787   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55788   arg2 = (void (*)(bool))jarg2;
55789   {
55790     try {
55791       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
55792     } catch (std::out_of_range& e) {
55793       {
55794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55795       };
55796     } catch (std::exception& e) {
55797       {
55798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55799       };
55800     } catch (...) {
55801       {
55802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55803       };
55804     }
55805   }
55806 }
55807
55808
55809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) {
55810   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55811   void (*arg2)(bool) = (void (*)(bool)) 0 ;
55812
55813   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55814   arg2 = (void (*)(bool))jarg2;
55815   {
55816     try {
55817       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
55818     } catch (std::out_of_range& e) {
55819       {
55820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55821       };
55822     } catch (std::exception& e) {
55823       {
55824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55825       };
55826     } catch (...) {
55827       {
55828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55829       };
55830     }
55831   }
55832 }
55833
55834
55835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, unsigned int jarg2) {
55836   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55837   bool arg2 ;
55838
55839   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55840   arg2 = jarg2 ? true : false;
55841   {
55842     try {
55843       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
55844     } catch (std::out_of_range& e) {
55845       {
55846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55847       };
55848     } catch (std::exception& e) {
55849       {
55850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55851       };
55852     } catch (...) {
55853       {
55854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55855       };
55856     }
55857   }
55858 }
55859
55860
55861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() {
55862   void * jresult ;
55863   Dali::Signal< void (bool) > *result = 0 ;
55864
55865   {
55866     try {
55867       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
55868     } catch (std::out_of_range& e) {
55869       {
55870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55871       };
55872     } catch (std::exception& e) {
55873       {
55874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55875       };
55876     } catch (...) {
55877       {
55878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55879       };
55880     }
55881   }
55882   jresult = (void *)result;
55883   return jresult;
55884 }
55885
55886
55887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) {
55888   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55889
55890   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55891   {
55892     try {
55893       delete arg1;
55894     } catch (std::out_of_range& e) {
55895       {
55896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55897       };
55898     } catch (std::exception& e) {
55899       {
55900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55901       };
55902     } catch (...) {
55903       {
55904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55905       };
55906     }
55907   }
55908 }
55909
55910
55911
55912
55913
55914
55915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55916   int jresult ;
55917   int result;
55918
55919   {
55920     try {
55921       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55922     } catch (std::out_of_range& e) {
55923       {
55924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55925       };
55926     } catch (std::exception& e) {
55927       {
55928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55929       };
55930     } catch (...) {
55931       {
55932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55933       };
55934     }
55935   }
55936   jresult = (int)result;
55937   return jresult;
55938 }
55939
55940
55941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55942   int jresult ;
55943   int result;
55944
55945   {
55946     try {
55947       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55948     } catch (std::out_of_range& e) {
55949       {
55950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55951       };
55952     } catch (std::exception& e) {
55953       {
55954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55955       };
55956     } catch (...) {
55957       {
55958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55959       };
55960     }
55961   }
55962   jresult = (int)result;
55963   return jresult;
55964 }
55965
55966
55967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55968   int jresult ;
55969   int result;
55970
55971   {
55972     try {
55973       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55974     } catch (std::out_of_range& e) {
55975       {
55976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55977       };
55978     } catch (std::exception& e) {
55979       {
55980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55981       };
55982     } catch (...) {
55983       {
55984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55985       };
55986     }
55987   }
55988   jresult = (int)result;
55989   return jresult;
55990 }
55991
55992
55993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55994   int jresult ;
55995   int result;
55996
55997   {
55998     try {
55999       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
56000     } catch (std::out_of_range& e) {
56001       {
56002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56003       };
56004     } catch (std::exception& e) {
56005       {
56006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56007       };
56008     } catch (...) {
56009       {
56010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56011       };
56012     }
56013   }
56014   jresult = (int)result;
56015   return jresult;
56016 }
56017
56018
56019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
56020   int jresult ;
56021   int result;
56022
56023   {
56024     try {
56025       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
56026     } catch (std::out_of_range& e) {
56027       {
56028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56029       };
56030     } catch (std::exception& e) {
56031       {
56032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56033       };
56034     } catch (...) {
56035       {
56036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56037       };
56038     }
56039   }
56040   jresult = (int)result;
56041   return jresult;
56042 }
56043
56044
56045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
56046   int jresult ;
56047   int result;
56048
56049   {
56050     try {
56051       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
56052     } catch (std::out_of_range& e) {
56053       {
56054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56055       };
56056     } catch (std::exception& e) {
56057       {
56058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56059       };
56060     } catch (...) {
56061       {
56062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56063       };
56064     }
56065   }
56066   jresult = (int)result;
56067   return jresult;
56068 }
56069
56070
56071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
56072   int jresult ;
56073   int result;
56074
56075   {
56076     try {
56077       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
56078     } catch (std::out_of_range& e) {
56079       {
56080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56081       };
56082     } catch (std::exception& e) {
56083       {
56084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56085       };
56086     } catch (...) {
56087       {
56088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56089       };
56090     }
56091   }
56092   jresult = (int)result;
56093   return jresult;
56094 }
56095
56096
56097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
56098   int jresult ;
56099   int result;
56100
56101   {
56102     try {
56103       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
56104     } catch (std::out_of_range& e) {
56105       {
56106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56107       };
56108     } catch (std::exception& e) {
56109       {
56110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56111       };
56112     } catch (...) {
56113       {
56114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56115       };
56116     }
56117   }
56118   jresult = (int)result;
56119   return jresult;
56120 }
56121
56122
56123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
56124   int jresult ;
56125   int result;
56126
56127   {
56128     try {
56129       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
56130     } catch (std::out_of_range& e) {
56131       {
56132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56133       };
56134     } catch (std::exception& e) {
56135       {
56136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56137       };
56138     } catch (...) {
56139       {
56140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56141       };
56142     }
56143   }
56144   jresult = (int)result;
56145   return jresult;
56146 }
56147
56148
56149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
56150   int jresult ;
56151   int result;
56152
56153   {
56154     try {
56155       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
56156     } catch (std::out_of_range& e) {
56157       {
56158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56159       };
56160     } catch (std::exception& e) {
56161       {
56162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56163       };
56164     } catch (...) {
56165       {
56166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56167       };
56168     }
56169   }
56170   jresult = (int)result;
56171   return jresult;
56172 }
56173
56174
56175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
56176   int jresult ;
56177   int result;
56178
56179   {
56180     try {
56181       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
56182     } catch (std::out_of_range& e) {
56183       {
56184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56185       };
56186     } catch (std::exception& e) {
56187       {
56188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56189       };
56190     } catch (...) {
56191       {
56192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56193       };
56194     }
56195   }
56196   jresult = (int)result;
56197   return jresult;
56198 }
56199
56200
56201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
56202   int jresult ;
56203   int result;
56204
56205   {
56206     try {
56207       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
56208     } catch (std::out_of_range& e) {
56209       {
56210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56211       };
56212     } catch (std::exception& e) {
56213       {
56214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56215       };
56216     } catch (...) {
56217       {
56218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56219       };
56220     }
56221   }
56222   jresult = (int)result;
56223   return jresult;
56224 }
56225
56226
56227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
56228   int jresult ;
56229   int result;
56230
56231   {
56232     try {
56233       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
56234     } catch (std::out_of_range& e) {
56235       {
56236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56237       };
56238     } catch (std::exception& e) {
56239       {
56240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56241       };
56242     } catch (...) {
56243       {
56244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56245       };
56246     }
56247   }
56248   jresult = (int)result;
56249   return jresult;
56250 }
56251
56252
56253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
56254   int jresult ;
56255   int result;
56256
56257   {
56258     try {
56259       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
56260     } catch (std::out_of_range& e) {
56261       {
56262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56263       };
56264     } catch (std::exception& e) {
56265       {
56266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56267       };
56268     } catch (...) {
56269       {
56270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56271       };
56272     }
56273   }
56274   jresult = (int)result;
56275   return jresult;
56276 }
56277
56278
56279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
56280   int jresult ;
56281   int result;
56282
56283   {
56284     try {
56285       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
56286     } catch (std::out_of_range& e) {
56287       {
56288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56289       };
56290     } catch (std::exception& e) {
56291       {
56292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56293       };
56294     } catch (...) {
56295       {
56296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56297       };
56298     }
56299   }
56300   jresult = (int)result;
56301   return jresult;
56302 }
56303
56304
56305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
56306   int jresult ;
56307   int result;
56308
56309   {
56310     try {
56311       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
56312     } catch (std::out_of_range& e) {
56313       {
56314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56315       };
56316     } catch (std::exception& e) {
56317       {
56318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56319       };
56320     } catch (...) {
56321       {
56322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56323       };
56324     }
56325   }
56326   jresult = (int)result;
56327   return jresult;
56328 }
56329
56330
56331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
56332   int jresult ;
56333   int result;
56334
56335   {
56336     try {
56337       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
56338     } catch (std::out_of_range& e) {
56339       {
56340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56341       };
56342     } catch (std::exception& e) {
56343       {
56344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56345       };
56346     } catch (...) {
56347       {
56348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56349       };
56350     }
56351   }
56352   jresult = (int)result;
56353   return jresult;
56354 }
56355
56356
56357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
56358   int jresult ;
56359   int result;
56360
56361   {
56362     try {
56363       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
56364     } catch (std::out_of_range& e) {
56365       {
56366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56367       };
56368     } catch (std::exception& e) {
56369       {
56370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56371       };
56372     } catch (...) {
56373       {
56374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56375       };
56376     }
56377   }
56378   jresult = (int)result;
56379   return jresult;
56380 }
56381
56382
56383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
56384   int jresult ;
56385   int result;
56386
56387   {
56388     try {
56389       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
56390     } catch (std::out_of_range& e) {
56391       {
56392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56393       };
56394     } catch (std::exception& e) {
56395       {
56396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56397       };
56398     } catch (...) {
56399       {
56400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56401       };
56402     }
56403   }
56404   jresult = (int)result;
56405   return jresult;
56406 }
56407
56408
56409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
56410   int jresult ;
56411   int result;
56412
56413   {
56414     try {
56415       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
56416     } catch (std::out_of_range& e) {
56417       {
56418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56419       };
56420     } catch (std::exception& e) {
56421       {
56422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56423       };
56424     } catch (...) {
56425       {
56426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56427       };
56428     }
56429   }
56430   jresult = (int)result;
56431   return jresult;
56432 }
56433
56434
56435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
56436   int jresult ;
56437   int result;
56438
56439   {
56440     try {
56441       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
56442     } catch (std::out_of_range& e) {
56443       {
56444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56445       };
56446     } catch (std::exception& e) {
56447       {
56448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56449       };
56450     } catch (...) {
56451       {
56452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56453       };
56454     }
56455   }
56456   jresult = (int)result;
56457   return jresult;
56458 }
56459
56460
56461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
56462   int jresult ;
56463   int result;
56464
56465   {
56466     try {
56467       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
56468     } catch (std::out_of_range& e) {
56469       {
56470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56471       };
56472     } catch (std::exception& e) {
56473       {
56474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56475       };
56476     } catch (...) {
56477       {
56478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56479       };
56480     }
56481   }
56482   jresult = (int)result;
56483   return jresult;
56484 }
56485
56486
56487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56488   int jresult ;
56489   int result;
56490
56491   {
56492     try {
56493       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56494     } catch (std::out_of_range& e) {
56495       {
56496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56497       };
56498     } catch (std::exception& e) {
56499       {
56500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56501       };
56502     } catch (...) {
56503       {
56504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56505       };
56506     }
56507   }
56508   jresult = (int)result;
56509   return jresult;
56510 }
56511
56512
56513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56514   int jresult ;
56515   int result;
56516
56517   {
56518     try {
56519       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56520     } catch (std::out_of_range& e) {
56521       {
56522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56523       };
56524     } catch (std::exception& e) {
56525       {
56526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56527       };
56528     } catch (...) {
56529       {
56530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56531       };
56532     }
56533   }
56534   jresult = (int)result;
56535   return jresult;
56536 }
56537
56538
56539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56540   int jresult ;
56541   int result;
56542
56543   {
56544     try {
56545       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56546     } catch (std::out_of_range& e) {
56547       {
56548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56549       };
56550     } catch (std::exception& e) {
56551       {
56552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56553       };
56554     } catch (...) {
56555       {
56556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56557       };
56558     }
56559   }
56560   jresult = (int)result;
56561   return jresult;
56562 }
56563
56564
56565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56566   int jresult ;
56567   int result;
56568
56569   {
56570     try {
56571       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56572     } catch (std::out_of_range& e) {
56573       {
56574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56575       };
56576     } catch (std::exception& e) {
56577       {
56578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56579       };
56580     } catch (...) {
56581       {
56582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56583       };
56584     }
56585   }
56586   jresult = (int)result;
56587   return jresult;
56588 }
56589
56590
56591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56592   int jresult ;
56593   int result;
56594
56595   {
56596     try {
56597       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56598     } catch (std::out_of_range& e) {
56599       {
56600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56601       };
56602     } catch (std::exception& e) {
56603       {
56604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56605       };
56606     } catch (...) {
56607       {
56608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56609       };
56610     }
56611   }
56612   jresult = (int)result;
56613   return jresult;
56614 }
56615
56616
56617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56618   int jresult ;
56619   int result;
56620
56621   {
56622     try {
56623       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56624     } catch (std::out_of_range& e) {
56625       {
56626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56627       };
56628     } catch (std::exception& e) {
56629       {
56630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56631       };
56632     } catch (...) {
56633       {
56634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56635       };
56636     }
56637   }
56638   jresult = (int)result;
56639   return jresult;
56640 }
56641
56642
56643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56644   int jresult ;
56645   int result;
56646
56647   {
56648     try {
56649       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56650     } catch (std::out_of_range& e) {
56651       {
56652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56653       };
56654     } catch (std::exception& e) {
56655       {
56656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56657       };
56658     } catch (...) {
56659       {
56660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56661       };
56662     }
56663   }
56664   jresult = (int)result;
56665   return jresult;
56666 }
56667
56668
56669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56670   int jresult ;
56671   int result;
56672
56673   {
56674     try {
56675       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56676     } catch (std::out_of_range& e) {
56677       {
56678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56679       };
56680     } catch (std::exception& e) {
56681       {
56682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56683       };
56684     } catch (...) {
56685       {
56686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56687       };
56688     }
56689   }
56690   jresult = (int)result;
56691   return jresult;
56692 }
56693
56694
56695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56696   int jresult ;
56697   int result;
56698
56699   {
56700     try {
56701       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56702     } catch (std::out_of_range& e) {
56703       {
56704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56705       };
56706     } catch (std::exception& e) {
56707       {
56708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56709       };
56710     } catch (...) {
56711       {
56712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56713       };
56714     }
56715   }
56716   jresult = (int)result;
56717   return jresult;
56718 }
56719
56720
56721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56722   int jresult ;
56723   int result;
56724
56725   {
56726     try {
56727       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56728     } catch (std::out_of_range& e) {
56729       {
56730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56731       };
56732     } catch (std::exception& e) {
56733       {
56734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56735       };
56736     } catch (...) {
56737       {
56738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56739       };
56740     }
56741   }
56742   jresult = (int)result;
56743   return jresult;
56744 }
56745
56746
56747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56748   int jresult ;
56749   int result;
56750
56751   {
56752     try {
56753       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56754     } catch (std::out_of_range& e) {
56755       {
56756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56757       };
56758     } catch (std::exception& e) {
56759       {
56760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56761       };
56762     } catch (...) {
56763       {
56764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56765       };
56766     }
56767   }
56768   jresult = (int)result;
56769   return jresult;
56770 }
56771
56772
56773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56774   int jresult ;
56775   int result;
56776
56777   {
56778     try {
56779       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56780     } catch (std::out_of_range& e) {
56781       {
56782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56783       };
56784     } catch (std::exception& e) {
56785       {
56786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56787       };
56788     } catch (...) {
56789       {
56790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56791       };
56792     }
56793   }
56794   jresult = (int)result;
56795   return jresult;
56796 }
56797
56798
56799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56800   int jresult ;
56801   int result;
56802
56803   {
56804     try {
56805       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56806     } catch (std::out_of_range& e) {
56807       {
56808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56809       };
56810     } catch (std::exception& e) {
56811       {
56812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56813       };
56814     } catch (...) {
56815       {
56816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56817       };
56818     }
56819   }
56820   jresult = (int)result;
56821   return jresult;
56822 }
56823
56824
56825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56826   int jresult ;
56827   int result;
56828
56829   {
56830     try {
56831       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56832     } catch (std::out_of_range& e) {
56833       {
56834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56835       };
56836     } catch (std::exception& e) {
56837       {
56838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56839       };
56840     } catch (...) {
56841       {
56842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56843       };
56844     }
56845   }
56846   jresult = (int)result;
56847   return jresult;
56848 }
56849
56850
56851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
56852   int jresult ;
56853   int result;
56854
56855   {
56856     try {
56857       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56858     } catch (std::out_of_range& e) {
56859       {
56860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56861       };
56862     } catch (std::exception& e) {
56863       {
56864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56865       };
56866     } catch (...) {
56867       {
56868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56869       };
56870     }
56871   }
56872   jresult = (int)result;
56873   return jresult;
56874 }
56875
56876
56877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56878   int jresult ;
56879   int result;
56880
56881   {
56882     try {
56883       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56884     } catch (std::out_of_range& e) {
56885       {
56886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56887       };
56888     } catch (std::exception& e) {
56889       {
56890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56891       };
56892     } catch (...) {
56893       {
56894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56895       };
56896     }
56897   }
56898   jresult = (int)result;
56899   return jresult;
56900 }
56901
56902
56903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
56904   int jresult ;
56905   int result;
56906
56907   {
56908     try {
56909       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56910     } catch (std::out_of_range& e) {
56911       {
56912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56913       };
56914     } catch (std::exception& e) {
56915       {
56916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56917       };
56918     } catch (...) {
56919       {
56920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56921       };
56922     }
56923   }
56924   jresult = (int)result;
56925   return jresult;
56926 }
56927
56928
56929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
56930   int jresult ;
56931   int result;
56932
56933   {
56934     try {
56935       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
56936     } catch (std::out_of_range& e) {
56937       {
56938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56939       };
56940     } catch (std::exception& e) {
56941       {
56942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56943       };
56944     } catch (...) {
56945       {
56946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56947       };
56948     }
56949   }
56950   jresult = (int)result;
56951   return jresult;
56952 }
56953
56954
56955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
56956   int jresult ;
56957   int result;
56958
56959   {
56960     try {
56961       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
56962     } catch (std::out_of_range& e) {
56963       {
56964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56965       };
56966     } catch (std::exception& e) {
56967       {
56968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56969       };
56970     } catch (...) {
56971       {
56972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56973       };
56974     }
56975   }
56976   jresult = (int)result;
56977   return jresult;
56978 }
56979
56980
56981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
56982   int jresult ;
56983   int result;
56984
56985   {
56986     try {
56987       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
56988     } catch (std::out_of_range& e) {
56989       {
56990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56991       };
56992     } catch (std::exception& e) {
56993       {
56994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56995       };
56996     } catch (...) {
56997       {
56998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56999       };
57000     }
57001   }
57002   jresult = (int)result;
57003   return jresult;
57004 }
57005
57006
57007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
57008   int jresult ;
57009   int result;
57010
57011   {
57012     try {
57013       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
57014     } catch (std::out_of_range& e) {
57015       {
57016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57017       };
57018     } catch (std::exception& e) {
57019       {
57020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57021       };
57022     } catch (...) {
57023       {
57024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57025       };
57026     }
57027   }
57028   jresult = (int)result;
57029   return jresult;
57030 }
57031
57032
57033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
57034   int jresult ;
57035   int result;
57036
57037   {
57038     try {
57039       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
57040     } catch (std::out_of_range& e) {
57041       {
57042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57043       };
57044     } catch (std::exception& e) {
57045       {
57046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57047       };
57048     } catch (...) {
57049       {
57050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57051       };
57052     }
57053   }
57054   jresult = (int)result;
57055   return jresult;
57056 }
57057
57058
57059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
57060   int jresult ;
57061   int result;
57062
57063   {
57064     try {
57065       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
57066     } catch (std::out_of_range& e) {
57067       {
57068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57069       };
57070     } catch (std::exception& e) {
57071       {
57072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57073       };
57074     } catch (...) {
57075       {
57076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57077       };
57078     }
57079   }
57080   jresult = (int)result;
57081   return jresult;
57082 }
57083
57084
57085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
57086   int jresult ;
57087   int result;
57088
57089   {
57090     try {
57091       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
57092     } catch (std::out_of_range& e) {
57093       {
57094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57095       };
57096     } catch (std::exception& e) {
57097       {
57098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57099       };
57100     } catch (...) {
57101       {
57102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57103       };
57104     }
57105   }
57106   jresult = (int)result;
57107   return jresult;
57108 }
57109
57110
57111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
57112   int jresult ;
57113   int result;
57114
57115   {
57116     try {
57117       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
57118     } catch (std::out_of_range& e) {
57119       {
57120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57121       };
57122     } catch (std::exception& e) {
57123       {
57124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57125       };
57126     } catch (...) {
57127       {
57128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57129       };
57130     }
57131   }
57132   jresult = (int)result;
57133   return jresult;
57134 }
57135
57136
57137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
57138   int jresult ;
57139   int result;
57140
57141   {
57142     try {
57143       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
57144     } catch (std::out_of_range& e) {
57145       {
57146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57147       };
57148     } catch (std::exception& e) {
57149       {
57150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57151       };
57152     } catch (...) {
57153       {
57154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57155       };
57156     }
57157   }
57158   jresult = (int)result;
57159   return jresult;
57160 }
57161
57162
57163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
57164   int jresult ;
57165   int result;
57166
57167   {
57168     try {
57169       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
57170     } catch (std::out_of_range& e) {
57171       {
57172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57173       };
57174     } catch (std::exception& e) {
57175       {
57176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57177       };
57178     } catch (...) {
57179       {
57180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57181       };
57182     }
57183   }
57184   jresult = (int)result;
57185   return jresult;
57186 }
57187
57188
57189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
57190   int jresult ;
57191   int result;
57192
57193   {
57194     try {
57195       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
57196     } catch (std::out_of_range& e) {
57197       {
57198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57199       };
57200     } catch (std::exception& e) {
57201       {
57202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57203       };
57204     } catch (...) {
57205       {
57206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57207       };
57208     }
57209   }
57210   jresult = (int)result;
57211   return jresult;
57212 }
57213
57214
57215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
57216   int jresult ;
57217   int result;
57218
57219   {
57220     try {
57221       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
57222     } catch (std::out_of_range& e) {
57223       {
57224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57225       };
57226     } catch (std::exception& e) {
57227       {
57228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57229       };
57230     } catch (...) {
57231       {
57232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57233       };
57234     }
57235   }
57236   jresult = (int)result;
57237   return jresult;
57238 }
57239
57240
57241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
57242   int jresult ;
57243   int result;
57244
57245   {
57246     try {
57247       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
57248     } catch (std::out_of_range& e) {
57249       {
57250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57251       };
57252     } catch (std::exception& e) {
57253       {
57254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57255       };
57256     } catch (...) {
57257       {
57258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57259       };
57260     }
57261   }
57262   jresult = (int)result;
57263   return jresult;
57264 }
57265
57266
57267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
57268   int jresult ;
57269   int result;
57270
57271   {
57272     try {
57273       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57274     } catch (std::out_of_range& e) {
57275       {
57276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57277       };
57278     } catch (std::exception& e) {
57279       {
57280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57281       };
57282     } catch (...) {
57283       {
57284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57285       };
57286     }
57287   }
57288   jresult = (int)result;
57289   return jresult;
57290 }
57291
57292
57293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57294   int jresult ;
57295   int result;
57296
57297   {
57298     try {
57299       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57300     } catch (std::out_of_range& e) {
57301       {
57302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57303       };
57304     } catch (std::exception& e) {
57305       {
57306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57307       };
57308     } catch (...) {
57309       {
57310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57311       };
57312     }
57313   }
57314   jresult = (int)result;
57315   return jresult;
57316 }
57317
57318
57319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57320   int jresult ;
57321   int result;
57322
57323   {
57324     try {
57325       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57326     } catch (std::out_of_range& e) {
57327       {
57328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57329       };
57330     } catch (std::exception& e) {
57331       {
57332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57333       };
57334     } catch (...) {
57335       {
57336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57337       };
57338     }
57339   }
57340   jresult = (int)result;
57341   return jresult;
57342 }
57343
57344
57345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57346   int jresult ;
57347   int result;
57348
57349   {
57350     try {
57351       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57352     } catch (std::out_of_range& e) {
57353       {
57354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57355       };
57356     } catch (std::exception& e) {
57357       {
57358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57359       };
57360     } catch (...) {
57361       {
57362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57363       };
57364     }
57365   }
57366   jresult = (int)result;
57367   return jresult;
57368 }
57369
57370
57371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57372   int jresult ;
57373   int result;
57374
57375   {
57376     try {
57377       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57378     } catch (std::out_of_range& e) {
57379       {
57380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57381       };
57382     } catch (std::exception& e) {
57383       {
57384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57385       };
57386     } catch (...) {
57387       {
57388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57389       };
57390     }
57391   }
57392   jresult = (int)result;
57393   return jresult;
57394 }
57395
57396
57397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57398   void * jresult ;
57399   Dali::Toolkit::Builder *result = 0 ;
57400
57401   {
57402     try {
57403       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57404     } catch (std::out_of_range& e) {
57405       {
57406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57407       };
57408     } catch (std::exception& e) {
57409       {
57410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57411       };
57412     } catch (...) {
57413       {
57414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57415       };
57416     }
57417   }
57418   jresult = (void *)result;
57419   return jresult;
57420 }
57421
57422
57423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57424   void * jresult ;
57425   Dali::Toolkit::Builder result;
57426
57427   {
57428     try {
57429       result = Dali::Toolkit::Builder::New();
57430     } catch (std::out_of_range& e) {
57431       {
57432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57433       };
57434     } catch (std::exception& e) {
57435       {
57436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57437       };
57438     } catch (...) {
57439       {
57440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57441       };
57442     }
57443   }
57444   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57445   return jresult;
57446 }
57447
57448
57449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57450   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57451
57452   arg1 = (Dali::Toolkit::Builder *)jarg1;
57453   {
57454     try {
57455       delete arg1;
57456     } catch (std::out_of_range& e) {
57457       {
57458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57459       };
57460     } catch (std::exception& e) {
57461       {
57462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57463       };
57464     } catch (...) {
57465       {
57466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57467       };
57468     }
57469   }
57470 }
57471
57472
57473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57474   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57475   std::string *arg2 = 0 ;
57476   Dali::Toolkit::Builder::UIFormat arg3 ;
57477
57478   arg1 = (Dali::Toolkit::Builder *)jarg1;
57479   if (!jarg2) {
57480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57481     return ;
57482   }
57483   std::string arg2_str(jarg2);
57484   arg2 = &arg2_str;
57485   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57486   {
57487     try {
57488       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57489     } catch (std::out_of_range& e) {
57490       {
57491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57492       };
57493     } catch (std::exception& e) {
57494       {
57495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57496       };
57497     } catch (...) {
57498       {
57499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57500       };
57501     }
57502   }
57503
57504   //argout typemap for const std::string&
57505
57506 }
57507
57508
57509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57510   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57511   std::string *arg2 = 0 ;
57512
57513   arg1 = (Dali::Toolkit::Builder *)jarg1;
57514   if (!jarg2) {
57515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57516     return ;
57517   }
57518   std::string arg2_str(jarg2);
57519   arg2 = &arg2_str;
57520   {
57521     try {
57522       (arg1)->LoadFromString((std::string const &)*arg2);
57523     } catch (std::out_of_range& e) {
57524       {
57525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57526       };
57527     } catch (std::exception& e) {
57528       {
57529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57530       };
57531     } catch (...) {
57532       {
57533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57534       };
57535     }
57536   }
57537
57538   //argout typemap for const std::string&
57539
57540 }
57541
57542
57543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57544   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57545   Dali::Property::Map *arg2 = 0 ;
57546
57547   arg1 = (Dali::Toolkit::Builder *)jarg1;
57548   arg2 = (Dali::Property::Map *)jarg2;
57549   if (!arg2) {
57550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57551     return ;
57552   }
57553   {
57554     try {
57555       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57556     } catch (std::out_of_range& e) {
57557       {
57558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57559       };
57560     } catch (std::exception& e) {
57561       {
57562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57563       };
57564     } catch (...) {
57565       {
57566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57567       };
57568     }
57569   }
57570 }
57571
57572
57573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57574   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57575   std::string *arg2 = 0 ;
57576   Dali::Property::Value *arg3 = 0 ;
57577
57578   arg1 = (Dali::Toolkit::Builder *)jarg1;
57579   if (!jarg2) {
57580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57581     return ;
57582   }
57583   std::string arg2_str(jarg2);
57584   arg2 = &arg2_str;
57585   arg3 = (Dali::Property::Value *)jarg3;
57586   if (!arg3) {
57587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57588     return ;
57589   }
57590   {
57591     try {
57592       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57593     } catch (std::out_of_range& e) {
57594       {
57595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57596       };
57597     } catch (std::exception& e) {
57598       {
57599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57600       };
57601     } catch (...) {
57602       {
57603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57604       };
57605     }
57606   }
57607
57608   //argout typemap for const std::string&
57609
57610 }
57611
57612
57613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57614   void * jresult ;
57615   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57616   Dali::Property::Map *result = 0 ;
57617
57618   arg1 = (Dali::Toolkit::Builder *)jarg1;
57619   {
57620     try {
57621       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57622     } catch (std::out_of_range& e) {
57623       {
57624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57625       };
57626     } catch (std::exception& e) {
57627       {
57628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57629       };
57630     } catch (...) {
57631       {
57632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57633       };
57634     }
57635   }
57636   jresult = (void *)result;
57637   return jresult;
57638 }
57639
57640
57641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57642   void * jresult ;
57643   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57644   std::string *arg2 = 0 ;
57645   Dali::Property::Value *result = 0 ;
57646
57647   arg1 = (Dali::Toolkit::Builder *)jarg1;
57648   if (!jarg2) {
57649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57650     return 0;
57651   }
57652   std::string arg2_str(jarg2);
57653   arg2 = &arg2_str;
57654   {
57655     try {
57656       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57657     } catch (std::out_of_range& e) {
57658       {
57659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57660       };
57661     } catch (std::exception& e) {
57662       {
57663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57664       };
57665     } catch (...) {
57666       {
57667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57668       };
57669     }
57670   }
57671   jresult = (void *)result;
57672
57673   //argout typemap for const std::string&
57674
57675   return jresult;
57676 }
57677
57678
57679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57680   void * jresult ;
57681   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57682   std::string *arg2 = 0 ;
57683   Dali::Animation result;
57684
57685   arg1 = (Dali::Toolkit::Builder *)jarg1;
57686   if (!jarg2) {
57687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57688     return 0;
57689   }
57690   std::string arg2_str(jarg2);
57691   arg2 = &arg2_str;
57692   {
57693     try {
57694       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57695     } catch (std::out_of_range& e) {
57696       {
57697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57698       };
57699     } catch (std::exception& e) {
57700       {
57701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57702       };
57703     } catch (...) {
57704       {
57705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57706       };
57707     }
57708   }
57709   jresult = new Dali::Animation((const Dali::Animation &)result);
57710
57711   //argout typemap for const std::string&
57712
57713   return jresult;
57714 }
57715
57716
57717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57718   void * jresult ;
57719   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57720   std::string *arg2 = 0 ;
57721   Dali::Property::Map *arg3 = 0 ;
57722   Dali::Animation result;
57723
57724   arg1 = (Dali::Toolkit::Builder *)jarg1;
57725   if (!jarg2) {
57726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57727     return 0;
57728   }
57729   std::string arg2_str(jarg2);
57730   arg2 = &arg2_str;
57731   arg3 = (Dali::Property::Map *)jarg3;
57732   if (!arg3) {
57733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57734     return 0;
57735   }
57736   {
57737     try {
57738       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57739     } catch (std::out_of_range& e) {
57740       {
57741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57742       };
57743     } catch (std::exception& e) {
57744       {
57745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57746       };
57747     } catch (...) {
57748       {
57749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57750       };
57751     }
57752   }
57753   jresult = new Dali::Animation((const Dali::Animation &)result);
57754
57755   //argout typemap for const std::string&
57756
57757   return jresult;
57758 }
57759
57760
57761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57762   void * jresult ;
57763   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57764   std::string *arg2 = 0 ;
57765   Dali::Actor arg3 ;
57766   Dali::Actor *argp3 ;
57767   Dali::Animation result;
57768
57769   arg1 = (Dali::Toolkit::Builder *)jarg1;
57770   if (!jarg2) {
57771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57772     return 0;
57773   }
57774   std::string arg2_str(jarg2);
57775   arg2 = &arg2_str;
57776   argp3 = (Dali::Actor *)jarg3;
57777   if (!argp3) {
57778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57779     return 0;
57780   }
57781   arg3 = *argp3;
57782   {
57783     try {
57784       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57785     } catch (std::out_of_range& e) {
57786       {
57787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57788       };
57789     } catch (std::exception& e) {
57790       {
57791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57792       };
57793     } catch (...) {
57794       {
57795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57796       };
57797     }
57798   }
57799   jresult = new Dali::Animation((const Dali::Animation &)result);
57800
57801   //argout typemap for const std::string&
57802
57803   return jresult;
57804 }
57805
57806
57807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
57808   void * jresult ;
57809   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57810   std::string *arg2 = 0 ;
57811   Dali::Property::Map *arg3 = 0 ;
57812   Dali::Actor arg4 ;
57813   Dali::Actor *argp4 ;
57814   Dali::Animation result;
57815
57816   arg1 = (Dali::Toolkit::Builder *)jarg1;
57817   if (!jarg2) {
57818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57819     return 0;
57820   }
57821   std::string arg2_str(jarg2);
57822   arg2 = &arg2_str;
57823   arg3 = (Dali::Property::Map *)jarg3;
57824   if (!arg3) {
57825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57826     return 0;
57827   }
57828   argp4 = (Dali::Actor *)jarg4;
57829   if (!argp4) {
57830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57831     return 0;
57832   }
57833   arg4 = *argp4;
57834   {
57835     try {
57836       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
57837     } catch (std::out_of_range& e) {
57838       {
57839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57840       };
57841     } catch (std::exception& e) {
57842       {
57843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57844       };
57845     } catch (...) {
57846       {
57847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57848       };
57849     }
57850   }
57851   jresult = new Dali::Animation((const Dali::Animation &)result);
57852
57853   //argout typemap for const std::string&
57854
57855   return jresult;
57856 }
57857
57858
57859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
57860   void * jresult ;
57861   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57862   std::string *arg2 = 0 ;
57863   Dali::BaseHandle result;
57864
57865   arg1 = (Dali::Toolkit::Builder *)jarg1;
57866   if (!jarg2) {
57867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57868     return 0;
57869   }
57870   std::string arg2_str(jarg2);
57871   arg2 = &arg2_str;
57872   {
57873     try {
57874       result = (arg1)->Create((std::string const &)*arg2);
57875     } catch (std::out_of_range& e) {
57876       {
57877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57878       };
57879     } catch (std::exception& e) {
57880       {
57881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57882       };
57883     } catch (...) {
57884       {
57885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57886       };
57887     }
57888   }
57889   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57890
57891   //argout typemap for const std::string&
57892
57893   return jresult;
57894 }
57895
57896
57897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57898   void * jresult ;
57899   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57900   std::string *arg2 = 0 ;
57901   Dali::Property::Map *arg3 = 0 ;
57902   Dali::BaseHandle result;
57903
57904   arg1 = (Dali::Toolkit::Builder *)jarg1;
57905   if (!jarg2) {
57906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57907     return 0;
57908   }
57909   std::string arg2_str(jarg2);
57910   arg2 = &arg2_str;
57911   arg3 = (Dali::Property::Map *)jarg3;
57912   if (!arg3) {
57913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57914     return 0;
57915   }
57916   {
57917     try {
57918       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57919     } catch (std::out_of_range& e) {
57920       {
57921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57922       };
57923     } catch (std::exception& e) {
57924       {
57925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57926       };
57927     } catch (...) {
57928       {
57929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57930       };
57931     }
57932   }
57933   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57934
57935   //argout typemap for const std::string&
57936
57937   return jresult;
57938 }
57939
57940
57941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
57942   void * jresult ;
57943   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57944   std::string *arg2 = 0 ;
57945   Dali::BaseHandle result;
57946
57947   arg1 = (Dali::Toolkit::Builder *)jarg1;
57948   if (!jarg2) {
57949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57950     return 0;
57951   }
57952   std::string arg2_str(jarg2);
57953   arg2 = &arg2_str;
57954   {
57955     try {
57956       result = (arg1)->CreateFromJson((std::string const &)*arg2);
57957     } catch (std::out_of_range& e) {
57958       {
57959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57960       };
57961     } catch (std::exception& e) {
57962       {
57963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57964       };
57965     } catch (...) {
57966       {
57967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57968       };
57969     }
57970   }
57971   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57972
57973   //argout typemap for const std::string&
57974
57975   return jresult;
57976 }
57977
57978
57979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
57980   unsigned int jresult ;
57981   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57982   std::string *arg2 = 0 ;
57983   Dali::Handle *arg3 = 0 ;
57984   bool result;
57985
57986   arg1 = (Dali::Toolkit::Builder *)jarg1;
57987   if (!jarg2) {
57988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57989     return 0;
57990   }
57991   std::string arg2_str(jarg2);
57992   arg2 = &arg2_str;
57993   arg3 = (Dali::Handle *)jarg3;
57994   if (!arg3) {
57995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57996     return 0;
57997   }
57998   {
57999     try {
58000       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
58001     } catch (std::out_of_range& e) {
58002       {
58003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58004       };
58005     } catch (std::exception& e) {
58006       {
58007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58008       };
58009     } catch (...) {
58010       {
58011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58012       };
58013     }
58014   }
58015   jresult = result;
58016
58017   //argout typemap for const std::string&
58018
58019   return jresult;
58020 }
58021
58022
58023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
58024   unsigned int jresult ;
58025   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58026   Dali::Handle *arg2 = 0 ;
58027   std::string *arg3 = 0 ;
58028   bool result;
58029
58030   arg1 = (Dali::Toolkit::Builder *)jarg1;
58031   arg2 = (Dali::Handle *)jarg2;
58032   if (!arg2) {
58033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58034     return 0;
58035   }
58036   if (!jarg3) {
58037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58038     return 0;
58039   }
58040   std::string arg3_str(jarg3);
58041   arg3 = &arg3_str;
58042   {
58043     try {
58044       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
58045     } catch (std::out_of_range& e) {
58046       {
58047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58048       };
58049     } catch (std::exception& e) {
58050       {
58051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58052       };
58053     } catch (...) {
58054       {
58055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58056       };
58057     }
58058   }
58059   jresult = result;
58060
58061   //argout typemap for const std::string&
58062
58063   return jresult;
58064 }
58065
58066
58067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
58068   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58069   Dali::Actor arg2 ;
58070   Dali::Actor *argp2 ;
58071
58072   arg1 = (Dali::Toolkit::Builder *)jarg1;
58073   argp2 = (Dali::Actor *)jarg2;
58074   if (!argp2) {
58075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58076     return ;
58077   }
58078   arg2 = *argp2;
58079   {
58080     try {
58081       (arg1)->AddActors(arg2);
58082     } catch (std::out_of_range& e) {
58083       {
58084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58085       };
58086     } catch (std::exception& e) {
58087       {
58088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58089       };
58090     } catch (...) {
58091       {
58092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58093       };
58094     }
58095   }
58096 }
58097
58098
58099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58100   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58101   std::string *arg2 = 0 ;
58102   Dali::Actor arg3 ;
58103   Dali::Actor *argp3 ;
58104
58105   arg1 = (Dali::Toolkit::Builder *)jarg1;
58106   if (!jarg2) {
58107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58108     return ;
58109   }
58110   std::string arg2_str(jarg2);
58111   arg2 = &arg2_str;
58112   argp3 = (Dali::Actor *)jarg3;
58113   if (!argp3) {
58114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58115     return ;
58116   }
58117   arg3 = *argp3;
58118   {
58119     try {
58120       (arg1)->AddActors((std::string const &)*arg2,arg3);
58121     } catch (std::out_of_range& e) {
58122       {
58123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58124       };
58125     } catch (std::exception& e) {
58126       {
58127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58128       };
58129     } catch (...) {
58130       {
58131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58132       };
58133     }
58134   }
58135
58136   //argout typemap for const std::string&
58137
58138 }
58139
58140
58141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
58142   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58143   std::string *arg2 = 0 ;
58144
58145   arg1 = (Dali::Toolkit::Builder *)jarg1;
58146   if (!jarg2) {
58147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58148     return ;
58149   }
58150   std::string arg2_str(jarg2);
58151   arg2 = &arg2_str;
58152   {
58153     try {
58154       (arg1)->CreateRenderTask((std::string const &)*arg2);
58155     } catch (std::out_of_range& e) {
58156       {
58157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58158       };
58159     } catch (std::exception& e) {
58160       {
58161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58162       };
58163     } catch (...) {
58164       {
58165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58166       };
58167     }
58168   }
58169
58170   //argout typemap for const std::string&
58171
58172 }
58173
58174
58175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
58176   void * jresult ;
58177   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58178   std::string *arg2 = 0 ;
58179   Dali::FrameBufferImage result;
58180
58181   arg1 = (Dali::Toolkit::Builder *)jarg1;
58182   if (!jarg2) {
58183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58184     return 0;
58185   }
58186   std::string arg2_str(jarg2);
58187   arg2 = &arg2_str;
58188   {
58189     try {
58190       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
58191     } catch (std::out_of_range& e) {
58192       {
58193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58194       };
58195     } catch (std::exception& e) {
58196       {
58197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58198       };
58199     } catch (...) {
58200       {
58201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58202       };
58203     }
58204   }
58205   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
58206
58207   //argout typemap for const std::string&
58208
58209   return jresult;
58210 }
58211
58212
58213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58214   void * jresult ;
58215   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58216   std::string *arg2 = 0 ;
58217   Dali::Path result;
58218
58219   arg1 = (Dali::Toolkit::Builder *)jarg1;
58220   if (!jarg2) {
58221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58222     return 0;
58223   }
58224   std::string arg2_str(jarg2);
58225   arg2 = &arg2_str;
58226   {
58227     try {
58228       result = (arg1)->GetPath((std::string const &)*arg2);
58229     } catch (std::out_of_range& e) {
58230       {
58231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58232       };
58233     } catch (std::exception& e) {
58234       {
58235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58236       };
58237     } catch (...) {
58238       {
58239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58240       };
58241     }
58242   }
58243   jresult = new Dali::Path((const Dali::Path &)result);
58244
58245   //argout typemap for const std::string&
58246
58247   return jresult;
58248 }
58249
58250
58251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58252   void * jresult ;
58253   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58254   std::string *arg2 = 0 ;
58255   Dali::PathConstrainer result;
58256
58257   arg1 = (Dali::Toolkit::Builder *)jarg1;
58258   if (!jarg2) {
58259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58260     return 0;
58261   }
58262   std::string arg2_str(jarg2);
58263   arg2 = &arg2_str;
58264   {
58265     try {
58266       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58267     } catch (std::out_of_range& e) {
58268       {
58269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58270       };
58271     } catch (std::exception& e) {
58272       {
58273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58274       };
58275     } catch (...) {
58276       {
58277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58278       };
58279     }
58280   }
58281   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58282
58283   //argout typemap for const std::string&
58284
58285   return jresult;
58286 }
58287
58288
58289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58290   void * jresult ;
58291   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58292   std::string *arg2 = 0 ;
58293   Dali::LinearConstrainer result;
58294
58295   arg1 = (Dali::Toolkit::Builder *)jarg1;
58296   if (!jarg2) {
58297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58298     return 0;
58299   }
58300   std::string arg2_str(jarg2);
58301   arg2 = &arg2_str;
58302   {
58303     try {
58304       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58305     } catch (std::out_of_range& e) {
58306       {
58307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58308       };
58309     } catch (std::exception& e) {
58310       {
58311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58312       };
58313     } catch (...) {
58314       {
58315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58316       };
58317     }
58318   }
58319   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58320
58321   //argout typemap for const std::string&
58322
58323   return jresult;
58324 }
58325
58326
58327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58328   void * jresult ;
58329   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58330   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58331
58332   arg1 = (Dali::Toolkit::Builder *)jarg1;
58333   {
58334     try {
58335       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
58336     } catch (std::out_of_range& e) {
58337       {
58338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58339       };
58340     } catch (std::exception& e) {
58341       {
58342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58343       };
58344     } catch (...) {
58345       {
58346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58347       };
58348     }
58349   }
58350   jresult = (void *)result;
58351   return jresult;
58352 }
58353
58354
58355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58356   void * jresult ;
58357   Dali::Toolkit::TransitionData *result = 0 ;
58358
58359   {
58360     try {
58361       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58362     } catch (std::out_of_range& e) {
58363       {
58364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58365       };
58366     } catch (std::exception& e) {
58367       {
58368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58369       };
58370     } catch (...) {
58371       {
58372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58373       };
58374     }
58375   }
58376   jresult = (void *)result;
58377   return jresult;
58378 }
58379
58380
58381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58382   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58383
58384   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58385   {
58386     try {
58387       delete arg1;
58388     } catch (std::out_of_range& e) {
58389       {
58390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58391       };
58392     } catch (std::exception& e) {
58393       {
58394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58395       };
58396     } catch (...) {
58397       {
58398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58399       };
58400     }
58401   }
58402 }
58403
58404
58405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58406   void * jresult ;
58407   Dali::Property::Map *arg1 = 0 ;
58408   Dali::Toolkit::TransitionData result;
58409
58410   arg1 = (Dali::Property::Map *)jarg1;
58411   if (!arg1) {
58412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58413     return 0;
58414   }
58415   {
58416     try {
58417       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58418     } catch (std::out_of_range& e) {
58419       {
58420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58421       };
58422     } catch (std::exception& e) {
58423       {
58424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58425       };
58426     } catch (...) {
58427       {
58428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58429       };
58430     }
58431   }
58432   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58433   return jresult;
58434 }
58435
58436
58437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58438   void * jresult ;
58439   Dali::Property::Array *arg1 = 0 ;
58440   Dali::Toolkit::TransitionData result;
58441
58442   arg1 = (Dali::Property::Array *)jarg1;
58443   if (!arg1) {
58444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58445     return 0;
58446   }
58447   {
58448     try {
58449       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58450     } catch (std::out_of_range& e) {
58451       {
58452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58453       };
58454     } catch (std::exception& e) {
58455       {
58456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58457       };
58458     } catch (...) {
58459       {
58460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58461       };
58462     }
58463   }
58464   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58465   return jresult;
58466 }
58467
58468
58469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58470   void * jresult ;
58471   Dali::BaseHandle arg1 ;
58472   Dali::BaseHandle *argp1 ;
58473   Dali::Toolkit::TransitionData result;
58474
58475   argp1 = (Dali::BaseHandle *)jarg1;
58476   if (!argp1) {
58477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58478     return 0;
58479   }
58480   arg1 = *argp1;
58481   {
58482     try {
58483       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58484     } catch (std::out_of_range& e) {
58485       {
58486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58487       };
58488     } catch (std::exception& e) {
58489       {
58490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58491       };
58492     } catch (...) {
58493       {
58494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58495       };
58496     }
58497   }
58498   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58499   return jresult;
58500 }
58501
58502
58503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58504   void * jresult ;
58505   Dali::Toolkit::TransitionData *arg1 = 0 ;
58506   Dali::Toolkit::TransitionData *result = 0 ;
58507
58508   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58509   if (!arg1) {
58510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58511     return 0;
58512   }
58513   {
58514     try {
58515       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58516     } catch (std::out_of_range& e) {
58517       {
58518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58519       };
58520     } catch (std::exception& e) {
58521       {
58522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58523       };
58524     } catch (...) {
58525       {
58526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58527       };
58528     }
58529   }
58530   jresult = (void *)result;
58531   return jresult;
58532 }
58533
58534
58535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58536   void * jresult ;
58537   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58538   Dali::Toolkit::TransitionData *arg2 = 0 ;
58539   Dali::Toolkit::TransitionData *result = 0 ;
58540
58541   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58542   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58543   if (!arg2) {
58544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58545     return 0;
58546   }
58547   {
58548     try {
58549       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58550     } catch (std::out_of_range& e) {
58551       {
58552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58553       };
58554     } catch (std::exception& e) {
58555       {
58556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58557       };
58558     } catch (...) {
58559       {
58560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58561       };
58562     }
58563   }
58564   jresult = (void *)result;
58565   return jresult;
58566 }
58567
58568
58569 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58570   unsigned long jresult ;
58571   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58572   size_t result;
58573
58574   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58575   {
58576     try {
58577       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58578     } catch (std::out_of_range& e) {
58579       {
58580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58581       };
58582     } catch (std::exception& e) {
58583       {
58584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58585       };
58586     } catch (...) {
58587       {
58588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58589       };
58590     }
58591   }
58592   jresult = (unsigned long)result;
58593   return jresult;
58594 }
58595
58596
58597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58598   void * jresult ;
58599   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58600   size_t arg2 ;
58601   Dali::Property::Map result;
58602
58603   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58604   arg2 = (size_t)jarg2;
58605   {
58606     try {
58607       result = (arg1)->GetAnimatorAt(arg2);
58608     } catch (std::out_of_range& e) {
58609       {
58610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58611       };
58612     } catch (std::exception& e) {
58613       {
58614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58615       };
58616     } catch (...) {
58617       {
58618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58619       };
58620     }
58621   }
58622   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
58623   return jresult;
58624 }
58625
58626
58627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
58628   void * jresult ;
58629   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
58630   Dali::Toolkit::TransitionData *result = 0 ;
58631
58632   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
58633   {
58634     try {
58635       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
58636     } catch (std::out_of_range& e) {
58637       {
58638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58639       };
58640     } catch (std::exception& e) {
58641       {
58642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58643       };
58644     } catch (...) {
58645       {
58646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58647       };
58648     }
58649   }
58650   jresult = (void *)result;
58651   return jresult;
58652 }
58653
58654
58655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58656   int jresult ;
58657   int result;
58658
58659   {
58660     try {
58661       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58662     } catch (std::out_of_range& e) {
58663       {
58664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58665       };
58666     } catch (std::exception& e) {
58667       {
58668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58669       };
58670     } catch (...) {
58671       {
58672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58673       };
58674     }
58675   }
58676   jresult = (int)result;
58677   return jresult;
58678 }
58679
58680
58681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58682   int jresult ;
58683   int result;
58684
58685   {
58686     try {
58687       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58688     } catch (std::out_of_range& e) {
58689       {
58690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58691       };
58692     } catch (std::exception& e) {
58693       {
58694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58695       };
58696     } catch (...) {
58697       {
58698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58699       };
58700     }
58701   }
58702   jresult = (int)result;
58703   return jresult;
58704 }
58705
58706
58707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58708   int jresult ;
58709   int result;
58710
58711   {
58712     try {
58713       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58714     } catch (std::out_of_range& e) {
58715       {
58716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58717       };
58718     } catch (std::exception& e) {
58719       {
58720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58721       };
58722     } catch (...) {
58723       {
58724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58725       };
58726     }
58727   }
58728   jresult = (int)result;
58729   return jresult;
58730 }
58731
58732
58733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58734   int jresult ;
58735   int result;
58736
58737   {
58738     try {
58739       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58740     } catch (std::out_of_range& e) {
58741       {
58742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58743       };
58744     } catch (std::exception& e) {
58745       {
58746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58747       };
58748     } catch (...) {
58749       {
58750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58751       };
58752     }
58753   }
58754   jresult = (int)result;
58755   return jresult;
58756 }
58757
58758
58759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58760   int jresult ;
58761   int result;
58762
58763   {
58764     try {
58765       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58766     } catch (std::out_of_range& e) {
58767       {
58768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58769       };
58770     } catch (std::exception& e) {
58771       {
58772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58773       };
58774     } catch (...) {
58775       {
58776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58777       };
58778     }
58779   }
58780   jresult = (int)result;
58781   return jresult;
58782 }
58783
58784
58785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
58786   int jresult ;
58787   int result;
58788
58789   {
58790     try {
58791       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
58792     } catch (std::out_of_range& e) {
58793       {
58794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58795       };
58796     } catch (std::exception& e) {
58797       {
58798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58799       };
58800     } catch (...) {
58801       {
58802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58803       };
58804     }
58805   }
58806   jresult = (int)result;
58807   return jresult;
58808 }
58809
58810
58811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
58812   int jresult ;
58813   int result;
58814
58815   {
58816     try {
58817       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
58818     } catch (std::out_of_range& e) {
58819       {
58820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58821       };
58822     } catch (std::exception& e) {
58823       {
58824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58825       };
58826     } catch (...) {
58827       {
58828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58829       };
58830     }
58831   }
58832   jresult = (int)result;
58833   return jresult;
58834 }
58835
58836
58837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
58838   int jresult ;
58839   int result;
58840
58841   {
58842     try {
58843       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
58844     } catch (std::out_of_range& e) {
58845       {
58846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58847       };
58848     } catch (std::exception& e) {
58849       {
58850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58851       };
58852     } catch (...) {
58853       {
58854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58855       };
58856     }
58857   }
58858   jresult = (int)result;
58859   return jresult;
58860 }
58861
58862
58863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
58864   int jresult ;
58865   int result;
58866
58867   {
58868     try {
58869       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
58870     } catch (std::out_of_range& e) {
58871       {
58872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58873       };
58874     } catch (std::exception& e) {
58875       {
58876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58877       };
58878     } catch (...) {
58879       {
58880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58881       };
58882     }
58883   }
58884   jresult = (int)result;
58885   return jresult;
58886 }
58887
58888
58889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
58890   int jresult ;
58891   int result;
58892
58893   {
58894     try {
58895       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
58896     } catch (std::out_of_range& e) {
58897       {
58898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58899       };
58900     } catch (std::exception& e) {
58901       {
58902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58903       };
58904     } catch (...) {
58905       {
58906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58907       };
58908     }
58909   }
58910   jresult = (int)result;
58911   return jresult;
58912 }
58913
58914
58915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
58916   int jresult ;
58917   int result;
58918
58919   {
58920     try {
58921       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
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 = (int)result;
58937   return jresult;
58938 }
58939
58940
58941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
58942   int jresult ;
58943   int result;
58944
58945   {
58946     try {
58947       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
58948     } catch (std::out_of_range& e) {
58949       {
58950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58951       };
58952     } catch (std::exception& e) {
58953       {
58954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58955       };
58956     } catch (...) {
58957       {
58958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58959       };
58960     }
58961   }
58962   jresult = (int)result;
58963   return jresult;
58964 }
58965
58966
58967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
58968   int jresult ;
58969   int result;
58970
58971   {
58972     try {
58973       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
58974     } catch (std::out_of_range& e) {
58975       {
58976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58977       };
58978     } catch (std::exception& e) {
58979       {
58980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58981       };
58982     } catch (...) {
58983       {
58984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58985       };
58986     }
58987   }
58988   jresult = (int)result;
58989   return jresult;
58990 }
58991
58992
58993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
58994   int jresult ;
58995   int result;
58996
58997   {
58998     try {
58999       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
59000     } catch (std::out_of_range& e) {
59001       {
59002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59003       };
59004     } catch (std::exception& e) {
59005       {
59006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59007       };
59008     } catch (...) {
59009       {
59010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59011       };
59012     }
59013   }
59014   jresult = (int)result;
59015   return jresult;
59016 }
59017
59018
59019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
59020   void * jresult ;
59021   Dali::Toolkit::Control result;
59022
59023   {
59024     try {
59025       result = Dali::Toolkit::Internal::Control::New();
59026     } catch (std::out_of_range& e) {
59027       {
59028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59029       };
59030     } catch (std::exception& e) {
59031       {
59032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59033       };
59034     } catch (...) {
59035       {
59036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59037       };
59038     }
59039   }
59040   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59041   return jresult;
59042 }
59043
59044
59045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59046   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59047   std::string *arg2 = 0 ;
59048
59049   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59050   if (!jarg2) {
59051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59052     return ;
59053   }
59054   std::string arg2_str(jarg2);
59055   arg2 = &arg2_str;
59056   {
59057     try {
59058       (arg1)->SetStyleName((std::string const &)*arg2);
59059     } catch (std::out_of_range& e) {
59060       {
59061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59062       };
59063     } catch (std::exception& e) {
59064       {
59065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59066       };
59067     } catch (...) {
59068       {
59069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59070       };
59071     }
59072   }
59073
59074   //argout typemap for const std::string&
59075
59076 }
59077
59078
59079 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59080   char * jresult ;
59081   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59082   std::string *result = 0 ;
59083
59084   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59085   {
59086     try {
59087       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59088     } catch (std::out_of_range& e) {
59089       {
59090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59091       };
59092     } catch (std::exception& e) {
59093       {
59094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59095       };
59096     } catch (...) {
59097       {
59098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59099       };
59100     }
59101   }
59102   jresult = SWIG_csharp_string_callback(result->c_str());
59103   return jresult;
59104 }
59105
59106
59107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59108   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59109   Dali::Vector4 *arg2 = 0 ;
59110
59111   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59112   arg2 = (Dali::Vector4 *)jarg2;
59113   if (!arg2) {
59114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59115     return ;
59116   }
59117   {
59118     try {
59119       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*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_GetBackgroundColor(void * jarg1) {
59138   void * jresult ;
59139   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59140   Dali::Vector4 result;
59141
59142   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59143   {
59144     try {
59145       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
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::Vector4((const Dali::Vector4 &)result);
59161   return jresult;
59162 }
59163
59164
59165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
59166   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59167   Dali::Image arg2 ;
59168   Dali::Image *argp2 ;
59169
59170   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59171   argp2 = (Dali::Image *)jarg2;
59172   if (!argp2) {
59173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
59174     return ;
59175   }
59176   arg2 = *argp2;
59177   {
59178     try {
59179       (arg1)->SetBackgroundImage(arg2);
59180     } catch (std::out_of_range& e) {
59181       {
59182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59183       };
59184     } catch (std::exception& e) {
59185       {
59186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59187       };
59188     } catch (...) {
59189       {
59190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59191       };
59192     }
59193   }
59194 }
59195
59196
59197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59198   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59199   Dali::Property::Map *arg2 = 0 ;
59200
59201   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59202   arg2 = (Dali::Property::Map *)jarg2;
59203   if (!arg2) {
59204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59205     return ;
59206   }
59207   {
59208     try {
59209       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59210     } catch (std::out_of_range& e) {
59211       {
59212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59213       };
59214     } catch (std::exception& e) {
59215       {
59216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59217       };
59218     } catch (...) {
59219       {
59220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59221       };
59222     }
59223   }
59224 }
59225
59226
59227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59228   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59229
59230   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59231   {
59232     try {
59233       (arg1)->ClearBackground();
59234     } catch (std::out_of_range& e) {
59235       {
59236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59237       };
59238     } catch (std::exception& e) {
59239       {
59240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59241       };
59242     } catch (...) {
59243       {
59244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59245       };
59246     }
59247   }
59248 }
59249
59250
59251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59252   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59253   Dali::Gesture::Type arg2 ;
59254
59255   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59256   arg2 = (Dali::Gesture::Type)jarg2;
59257   {
59258     try {
59259       (arg1)->EnableGestureDetection(arg2);
59260     } catch (std::out_of_range& e) {
59261       {
59262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59263       };
59264     } catch (std::exception& e) {
59265       {
59266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59267       };
59268     } catch (...) {
59269       {
59270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59271       };
59272     }
59273   }
59274 }
59275
59276
59277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59278   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59279   Dali::Gesture::Type arg2 ;
59280
59281   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59282   arg2 = (Dali::Gesture::Type)jarg2;
59283   {
59284     try {
59285       (arg1)->DisableGestureDetection(arg2);
59286     } catch (std::out_of_range& e) {
59287       {
59288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59289       };
59290     } catch (std::exception& e) {
59291       {
59292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59293       };
59294     } catch (...) {
59295       {
59296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59297       };
59298     }
59299   }
59300 }
59301
59302
59303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59304   void * jresult ;
59305   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59306   Dali::PinchGestureDetector result;
59307
59308   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59309   {
59310     try {
59311       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59312     } catch (std::out_of_range& e) {
59313       {
59314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59315       };
59316     } catch (std::exception& e) {
59317       {
59318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59319       };
59320     } catch (...) {
59321       {
59322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59323       };
59324     }
59325   }
59326   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59327   return jresult;
59328 }
59329
59330
59331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59332   void * jresult ;
59333   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59334   Dali::PanGestureDetector result;
59335
59336   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59337   {
59338     try {
59339       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59340     } catch (std::out_of_range& e) {
59341       {
59342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59343       };
59344     } catch (std::exception& e) {
59345       {
59346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59347       };
59348     } catch (...) {
59349       {
59350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59351       };
59352     }
59353   }
59354   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59355   return jresult;
59356 }
59357
59358
59359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59360   void * jresult ;
59361   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59362   Dali::TapGestureDetector result;
59363
59364   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59365   {
59366     try {
59367       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59368     } catch (std::out_of_range& e) {
59369       {
59370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59371       };
59372     } catch (std::exception& e) {
59373       {
59374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59375       };
59376     } catch (...) {
59377       {
59378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59379       };
59380     }
59381   }
59382   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59383   return jresult;
59384 }
59385
59386
59387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59388   void * jresult ;
59389   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59390   Dali::LongPressGestureDetector result;
59391
59392   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59393   {
59394     try {
59395       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59396     } catch (std::out_of_range& e) {
59397       {
59398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59399       };
59400     } catch (std::exception& e) {
59401       {
59402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59403       };
59404     } catch (...) {
59405       {
59406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59407       };
59408     }
59409   }
59410   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59411   return jresult;
59412 }
59413
59414
59415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59416   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59417   bool arg2 ;
59418
59419   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59420   arg2 = jarg2 ? true : false;
59421   {
59422     try {
59423       (arg1)->SetKeyboardNavigationSupport(arg2);
59424     } catch (std::out_of_range& e) {
59425       {
59426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59427       };
59428     } catch (std::exception& e) {
59429       {
59430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59431       };
59432     } catch (...) {
59433       {
59434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59435       };
59436     }
59437   }
59438 }
59439
59440
59441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59442   unsigned int jresult ;
59443   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59444   bool result;
59445
59446   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59447   {
59448     try {
59449       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59450     } catch (std::out_of_range& e) {
59451       {
59452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59453       };
59454     } catch (std::exception& e) {
59455       {
59456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59457       };
59458     } catch (...) {
59459       {
59460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59461       };
59462     }
59463   }
59464   jresult = result;
59465   return jresult;
59466 }
59467
59468
59469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59470   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59471
59472   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59473   {
59474     try {
59475       (arg1)->SetKeyInputFocus();
59476     } catch (std::out_of_range& e) {
59477       {
59478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59479       };
59480     } catch (std::exception& e) {
59481       {
59482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59483       };
59484     } catch (...) {
59485       {
59486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59487       };
59488     }
59489   }
59490 }
59491
59492
59493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
59494   unsigned int jresult ;
59495   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59496   bool result;
59497
59498   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59499   {
59500     try {
59501       result = (bool)(arg1)->HasKeyInputFocus();
59502     } catch (std::out_of_range& e) {
59503       {
59504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59505       };
59506     } catch (std::exception& e) {
59507       {
59508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59509       };
59510     } catch (...) {
59511       {
59512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59513       };
59514     }
59515   }
59516   jresult = result;
59517   return jresult;
59518 }
59519
59520
59521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
59522   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59523
59524   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59525   {
59526     try {
59527       (arg1)->ClearKeyInputFocus();
59528     } catch (std::out_of_range& e) {
59529       {
59530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59531       };
59532     } catch (std::exception& e) {
59533       {
59534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59535       };
59536     } catch (...) {
59537       {
59538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59539       };
59540     }
59541   }
59542 }
59543
59544
59545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
59546   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59547   bool arg2 ;
59548
59549   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59550   arg2 = jarg2 ? true : false;
59551   {
59552     try {
59553       (arg1)->SetAsKeyboardFocusGroup(arg2);
59554     } catch (std::out_of_range& e) {
59555       {
59556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59557       };
59558     } catch (std::exception& e) {
59559       {
59560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59561       };
59562     } catch (...) {
59563       {
59564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59565       };
59566     }
59567   }
59568 }
59569
59570
59571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
59572   unsigned int jresult ;
59573   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59574   bool result;
59575
59576   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59577   {
59578     try {
59579       result = (bool)(arg1)->IsKeyboardFocusGroup();
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_AccessibilityActivate(void * jarg1) {
59600   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59601
59602   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59603   {
59604     try {
59605       (arg1)->AccessibilityActivate();
59606     } catch (std::out_of_range& e) {
59607       {
59608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59609       };
59610     } catch (std::exception& e) {
59611       {
59612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59613       };
59614     } catch (...) {
59615       {
59616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59617       };
59618     }
59619   }
59620 }
59621
59622
59623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
59624   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59625
59626   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59627   {
59628     try {
59629       (arg1)->KeyboardEnter();
59630     } catch (std::out_of_range& e) {
59631       {
59632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59633       };
59634     } catch (std::exception& e) {
59635       {
59636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59637       };
59638     } catch (...) {
59639       {
59640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59641       };
59642     }
59643   }
59644 }
59645
59646
59647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59648   void * jresult ;
59649   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59650   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59651
59652   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59653   {
59654     try {
59655       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59656     } catch (std::out_of_range& e) {
59657       {
59658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59659       };
59660     } catch (std::exception& e) {
59661       {
59662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59663       };
59664     } catch (...) {
59665       {
59666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59667       };
59668     }
59669   }
59670   jresult = (void *)result;
59671   return jresult;
59672 }
59673
59674
59675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59676   void * jresult ;
59677   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59678   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59679
59680   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59681   {
59682     try {
59683       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59684     } catch (std::out_of_range& e) {
59685       {
59686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59687       };
59688     } catch (std::exception& e) {
59689       {
59690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59691       };
59692     } catch (...) {
59693       {
59694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59695       };
59696     }
59697   }
59698   jresult = (void *)result;
59699   return jresult;
59700 }
59701
59702
59703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
59704   void * jresult ;
59705   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59706   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59707
59708   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59709   {
59710     try {
59711       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59712     } catch (std::out_of_range& e) {
59713       {
59714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59715       };
59716     } catch (std::exception& e) {
59717       {
59718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59719       };
59720     } catch (...) {
59721       {
59722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59723       };
59724     }
59725   }
59726   jresult = (void *)result;
59727   return jresult;
59728 }
59729
59730
59731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
59732   unsigned int jresult ;
59733   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59734   Dali::KeyEvent *arg2 = 0 ;
59735   bool result;
59736
59737   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59738   arg2 = (Dali::KeyEvent *)jarg2;
59739   if (!arg2) {
59740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
59741     return 0;
59742   }
59743   {
59744     try {
59745       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
59746     } catch (std::out_of_range& e) {
59747       {
59748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59749       };
59750     } catch (std::exception& e) {
59751       {
59752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59753       };
59754     } catch (...) {
59755       {
59756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59757       };
59758     }
59759   }
59760   jresult = result;
59761   return jresult;
59762 }
59763
59764
59765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
59766   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59767   int arg2 ;
59768   SwigDirector_ViewImpl *darg = 0;
59769
59770   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59771   arg2 = (int)jarg2;
59772   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59773   {
59774     try {
59775       (darg)->OnStageConnection(arg2);
59776     } catch (std::out_of_range& e) {
59777       {
59778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59779       };
59780     } catch (std::exception& e) {
59781       {
59782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59783       };
59784     } catch (...) {
59785       {
59786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59787       };
59788     }
59789   }
59790 }
59791
59792
59793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
59794   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59795   int arg2 ;
59796   SwigDirector_ViewImpl *darg = 0;
59797
59798   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59799   arg2 = (int)jarg2;
59800   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59801   {
59802     try {
59803       (darg)->OnStageConnectionSwigPublic(arg2);
59804     } catch (std::out_of_range& e) {
59805       {
59806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59807       };
59808     } catch (std::exception& e) {
59809       {
59810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59811       };
59812     } catch (...) {
59813       {
59814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59815       };
59816     }
59817   }
59818 }
59819
59820
59821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
59822   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59823   SwigDirector_ViewImpl *darg = 0;
59824
59825   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59826   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59827   {
59828     try {
59829       (darg)->OnStageDisconnection();
59830     } catch (std::out_of_range& e) {
59831       {
59832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59833       };
59834     } catch (std::exception& e) {
59835       {
59836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59837       };
59838     } catch (...) {
59839       {
59840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59841       };
59842     }
59843   }
59844 }
59845
59846
59847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
59848   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59849   SwigDirector_ViewImpl *darg = 0;
59850
59851   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59852   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59853   {
59854     try {
59855       (darg)->OnStageDisconnectionSwigPublic();
59856     } catch (std::out_of_range& e) {
59857       {
59858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59859       };
59860     } catch (std::exception& e) {
59861       {
59862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59863       };
59864     } catch (...) {
59865       {
59866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59867       };
59868     }
59869   }
59870 }
59871
59872
59873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
59874   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59875   Dali::Actor *arg2 = 0 ;
59876   SwigDirector_ViewImpl *darg = 0;
59877
59878   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59879   arg2 = (Dali::Actor *)jarg2;
59880   if (!arg2) {
59881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59882     return ;
59883   }
59884   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59885   {
59886     try {
59887       (darg)->OnChildAdd(*arg2);
59888     } catch (std::out_of_range& e) {
59889       {
59890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59891       };
59892     } catch (std::exception& e) {
59893       {
59894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59895       };
59896     } catch (...) {
59897       {
59898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59899       };
59900     }
59901   }
59902 }
59903
59904
59905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59906   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59907   Dali::Actor *arg2 = 0 ;
59908   SwigDirector_ViewImpl *darg = 0;
59909
59910   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59911   arg2 = (Dali::Actor *)jarg2;
59912   if (!arg2) {
59913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59914     return ;
59915   }
59916   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59917   {
59918     try {
59919       (darg)->OnChildAddSwigPublic(*arg2);
59920     } catch (std::out_of_range& e) {
59921       {
59922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59923       };
59924     } catch (std::exception& e) {
59925       {
59926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59927       };
59928     } catch (...) {
59929       {
59930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59931       };
59932     }
59933   }
59934 }
59935
59936
59937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
59938   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59939   Dali::Actor *arg2 = 0 ;
59940   SwigDirector_ViewImpl *darg = 0;
59941
59942   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59943   arg2 = (Dali::Actor *)jarg2;
59944   if (!arg2) {
59945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59946     return ;
59947   }
59948   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59949   {
59950     try {
59951       (darg)->OnChildRemove(*arg2);
59952     } catch (std::out_of_range& e) {
59953       {
59954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59955       };
59956     } catch (std::exception& e) {
59957       {
59958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59959       };
59960     } catch (...) {
59961       {
59962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59963       };
59964     }
59965   }
59966 }
59967
59968
59969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59970   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59971   Dali::Actor *arg2 = 0 ;
59972   SwigDirector_ViewImpl *darg = 0;
59973
59974   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59975   arg2 = (Dali::Actor *)jarg2;
59976   if (!arg2) {
59977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59978     return ;
59979   }
59980   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59981   {
59982     try {
59983       (darg)->OnChildRemoveSwigPublic(*arg2);
59984     } catch (std::out_of_range& e) {
59985       {
59986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59987       };
59988     } catch (std::exception& e) {
59989       {
59990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59991       };
59992     } catch (...) {
59993       {
59994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59995       };
59996     }
59997   }
59998 }
59999
60000
60001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60002   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60003   Dali::Property::Index arg2 ;
60004   Dali::Property::Value arg3 ;
60005   Dali::Property::Value *argp3 ;
60006   SwigDirector_ViewImpl *darg = 0;
60007
60008   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60009   arg2 = (Dali::Property::Index)jarg2;
60010   argp3 = (Dali::Property::Value *)jarg3;
60011   if (!argp3) {
60012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60013     return ;
60014   }
60015   arg3 = *argp3;
60016   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60017   {
60018     try {
60019       (darg)->OnPropertySet(arg2,arg3);
60020     } catch (std::out_of_range& e) {
60021       {
60022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60023       };
60024     } catch (std::exception& e) {
60025       {
60026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60027       };
60028     } catch (...) {
60029       {
60030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60031       };
60032     }
60033   }
60034 }
60035
60036
60037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60038   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60039   Dali::Property::Index arg2 ;
60040   Dali::Property::Value arg3 ;
60041   Dali::Property::Value *argp3 ;
60042   SwigDirector_ViewImpl *darg = 0;
60043
60044   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60045   arg2 = (Dali::Property::Index)jarg2;
60046   argp3 = (Dali::Property::Value *)jarg3;
60047   if (!argp3) {
60048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60049     return ;
60050   }
60051   arg3 = *argp3;
60052   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60053   {
60054     try {
60055       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60056     } catch (std::out_of_range& e) {
60057       {
60058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60059       };
60060     } catch (std::exception& e) {
60061       {
60062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60063       };
60064     } catch (...) {
60065       {
60066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60067       };
60068     }
60069   }
60070 }
60071
60072
60073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60074   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60075   Dali::Vector3 *arg2 = 0 ;
60076   SwigDirector_ViewImpl *darg = 0;
60077
60078   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60079   arg2 = (Dali::Vector3 *)jarg2;
60080   if (!arg2) {
60081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60082     return ;
60083   }
60084   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60085   {
60086     try {
60087       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60088     } catch (std::out_of_range& e) {
60089       {
60090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60091       };
60092     } catch (std::exception& e) {
60093       {
60094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60095       };
60096     } catch (...) {
60097       {
60098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60099       };
60100     }
60101   }
60102 }
60103
60104
60105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60106   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60107   Dali::Vector3 *arg2 = 0 ;
60108   SwigDirector_ViewImpl *darg = 0;
60109
60110   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60111   arg2 = (Dali::Vector3 *)jarg2;
60112   if (!arg2) {
60113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60114     return ;
60115   }
60116   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60117   {
60118     try {
60119       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60120     } catch (std::out_of_range& e) {
60121       {
60122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60123       };
60124     } catch (std::exception& e) {
60125       {
60126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60127       };
60128     } catch (...) {
60129       {
60130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60131       };
60132     }
60133   }
60134 }
60135
60136
60137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60138   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60139   Dali::Animation *arg2 = 0 ;
60140   Dali::Vector3 *arg3 = 0 ;
60141   SwigDirector_ViewImpl *darg = 0;
60142
60143   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60144   arg2 = (Dali::Animation *)jarg2;
60145   if (!arg2) {
60146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60147     return ;
60148   }
60149   arg3 = (Dali::Vector3 *)jarg3;
60150   if (!arg3) {
60151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60152     return ;
60153   }
60154   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60155   {
60156     try {
60157       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60158     } catch (std::out_of_range& e) {
60159       {
60160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60161       };
60162     } catch (std::exception& e) {
60163       {
60164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60165       };
60166     } catch (...) {
60167       {
60168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60169       };
60170     }
60171   }
60172 }
60173
60174
60175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60176   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60177   Dali::Animation *arg2 = 0 ;
60178   Dali::Vector3 *arg3 = 0 ;
60179   SwigDirector_ViewImpl *darg = 0;
60180
60181   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60182   arg2 = (Dali::Animation *)jarg2;
60183   if (!arg2) {
60184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60185     return ;
60186   }
60187   arg3 = (Dali::Vector3 *)jarg3;
60188   if (!arg3) {
60189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60190     return ;
60191   }
60192   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60193   {
60194     try {
60195       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60196     } catch (std::out_of_range& e) {
60197       {
60198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60199       };
60200     } catch (std::exception& e) {
60201       {
60202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60203       };
60204     } catch (...) {
60205       {
60206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60207       };
60208     }
60209   }
60210 }
60211
60212
60213 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
60214   unsigned int jresult ;
60215   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60216   Dali::TouchEvent *arg2 = 0 ;
60217   SwigDirector_ViewImpl *darg = 0;
60218   bool result;
60219
60220   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60221   arg2 = (Dali::TouchEvent *)jarg2;
60222   if (!arg2) {
60223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60224     return 0;
60225   }
60226   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60227   {
60228     try {
60229       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
60230     } catch (std::out_of_range& e) {
60231       {
60232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60233       };
60234     } catch (std::exception& e) {
60235       {
60236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60237       };
60238     } catch (...) {
60239       {
60240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60241       };
60242     }
60243   }
60244   jresult = result;
60245   return jresult;
60246 }
60247
60248
60249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60250   unsigned int jresult ;
60251   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60252   Dali::TouchEvent *arg2 = 0 ;
60253   SwigDirector_ViewImpl *darg = 0;
60254   bool result;
60255
60256   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60257   arg2 = (Dali::TouchEvent *)jarg2;
60258   if (!arg2) {
60259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60260     return 0;
60261   }
60262   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60263   {
60264     try {
60265       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
60266     } catch (std::out_of_range& e) {
60267       {
60268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60269       };
60270     } catch (std::exception& e) {
60271       {
60272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60273       };
60274     } catch (...) {
60275       {
60276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60277       };
60278     }
60279   }
60280   jresult = result;
60281   return jresult;
60282 }
60283
60284
60285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60286   unsigned int jresult ;
60287   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60288   Dali::HoverEvent *arg2 = 0 ;
60289   SwigDirector_ViewImpl *darg = 0;
60290   bool result;
60291
60292   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60293   arg2 = (Dali::HoverEvent *)jarg2;
60294   if (!arg2) {
60295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60296     return 0;
60297   }
60298   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60299   {
60300     try {
60301       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60302     } catch (std::out_of_range& e) {
60303       {
60304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60305       };
60306     } catch (std::exception& e) {
60307       {
60308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60309       };
60310     } catch (...) {
60311       {
60312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60313       };
60314     }
60315   }
60316   jresult = result;
60317   return jresult;
60318 }
60319
60320
60321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60322   unsigned int jresult ;
60323   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60324   Dali::HoverEvent *arg2 = 0 ;
60325   SwigDirector_ViewImpl *darg = 0;
60326   bool result;
60327
60328   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60329   arg2 = (Dali::HoverEvent *)jarg2;
60330   if (!arg2) {
60331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60332     return 0;
60333   }
60334   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60335   {
60336     try {
60337       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60338     } catch (std::out_of_range& e) {
60339       {
60340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60341       };
60342     } catch (std::exception& e) {
60343       {
60344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60345       };
60346     } catch (...) {
60347       {
60348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60349       };
60350     }
60351   }
60352   jresult = result;
60353   return jresult;
60354 }
60355
60356
60357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60358   unsigned int jresult ;
60359   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60360   Dali::KeyEvent *arg2 = 0 ;
60361   SwigDirector_ViewImpl *darg = 0;
60362   bool result;
60363
60364   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60365   arg2 = (Dali::KeyEvent *)jarg2;
60366   if (!arg2) {
60367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60368     return 0;
60369   }
60370   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60371   {
60372     try {
60373       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60374     } catch (std::out_of_range& e) {
60375       {
60376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60377       };
60378     } catch (std::exception& e) {
60379       {
60380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60381       };
60382     } catch (...) {
60383       {
60384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60385       };
60386     }
60387   }
60388   jresult = result;
60389   return jresult;
60390 }
60391
60392
60393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60394   unsigned int jresult ;
60395   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60396   Dali::KeyEvent *arg2 = 0 ;
60397   SwigDirector_ViewImpl *darg = 0;
60398   bool result;
60399
60400   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60401   arg2 = (Dali::KeyEvent *)jarg2;
60402   if (!arg2) {
60403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60404     return 0;
60405   }
60406   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60407   {
60408     try {
60409       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60410     } catch (std::out_of_range& e) {
60411       {
60412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60413       };
60414     } catch (std::exception& e) {
60415       {
60416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60417       };
60418     } catch (...) {
60419       {
60420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60421       };
60422     }
60423   }
60424   jresult = result;
60425   return jresult;
60426 }
60427
60428
60429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
60430   unsigned int jresult ;
60431   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60432   Dali::WheelEvent *arg2 = 0 ;
60433   SwigDirector_ViewImpl *darg = 0;
60434   bool result;
60435
60436   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60437   arg2 = (Dali::WheelEvent *)jarg2;
60438   if (!arg2) {
60439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60440     return 0;
60441   }
60442   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60443   {
60444     try {
60445       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
60446     } catch (std::out_of_range& e) {
60447       {
60448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60449       };
60450     } catch (std::exception& e) {
60451       {
60452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60453       };
60454     } catch (...) {
60455       {
60456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60457       };
60458     }
60459   }
60460   jresult = result;
60461   return jresult;
60462 }
60463
60464
60465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60466   unsigned int jresult ;
60467   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60468   Dali::WheelEvent *arg2 = 0 ;
60469   SwigDirector_ViewImpl *darg = 0;
60470   bool result;
60471
60472   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60473   arg2 = (Dali::WheelEvent *)jarg2;
60474   if (!arg2) {
60475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60476     return 0;
60477   }
60478   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60479   {
60480     try {
60481       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
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 = result;
60497   return jresult;
60498 }
60499
60500
60501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
60502   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60503   Dali::Vector2 *arg2 = 0 ;
60504   Dali::RelayoutContainer *arg3 = 0 ;
60505   SwigDirector_ViewImpl *darg = 0;
60506
60507   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60508   arg2 = (Dali::Vector2 *)jarg2;
60509   if (!arg2) {
60510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60511     return ;
60512   }
60513   arg3 = (Dali::RelayoutContainer *)jarg3;
60514   if (!arg3) {
60515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60516     return ;
60517   }
60518   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60519   {
60520     try {
60521       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
60522     } catch (std::out_of_range& e) {
60523       {
60524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60525       };
60526     } catch (std::exception& e) {
60527       {
60528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60529       };
60530     } catch (...) {
60531       {
60532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60533       };
60534     }
60535   }
60536 }
60537
60538
60539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60540   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60541   Dali::Vector2 *arg2 = 0 ;
60542   Dali::RelayoutContainer *arg3 = 0 ;
60543   SwigDirector_ViewImpl *darg = 0;
60544
60545   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60546   arg2 = (Dali::Vector2 *)jarg2;
60547   if (!arg2) {
60548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60549     return ;
60550   }
60551   arg3 = (Dali::RelayoutContainer *)jarg3;
60552   if (!arg3) {
60553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60554     return ;
60555   }
60556   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60557   {
60558     try {
60559       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
60560     } catch (std::out_of_range& e) {
60561       {
60562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60563       };
60564     } catch (std::exception& e) {
60565       {
60566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60567       };
60568     } catch (...) {
60569       {
60570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60571       };
60572     }
60573   }
60574 }
60575
60576
60577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
60578   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60579   Dali::ResizePolicy::Type arg2 ;
60580   Dali::Dimension::Type arg3 ;
60581   SwigDirector_ViewImpl *darg = 0;
60582
60583   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60584   arg2 = (Dali::ResizePolicy::Type)jarg2;
60585   arg3 = (Dali::Dimension::Type)jarg3;
60586   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60587   {
60588     try {
60589       (darg)->OnSetResizePolicy(arg2,arg3);
60590     } catch (std::out_of_range& e) {
60591       {
60592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60593       };
60594     } catch (std::exception& e) {
60595       {
60596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60597       };
60598     } catch (...) {
60599       {
60600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60601       };
60602     }
60603   }
60604 }
60605
60606
60607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
60608   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60609   Dali::ResizePolicy::Type arg2 ;
60610   Dali::Dimension::Type arg3 ;
60611   SwigDirector_ViewImpl *darg = 0;
60612
60613   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60614   arg2 = (Dali::ResizePolicy::Type)jarg2;
60615   arg3 = (Dali::Dimension::Type)jarg3;
60616   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60617   {
60618     try {
60619       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
60620     } catch (std::out_of_range& e) {
60621       {
60622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60623       };
60624     } catch (std::exception& e) {
60625       {
60626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60627       };
60628     } catch (...) {
60629       {
60630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60631       };
60632     }
60633   }
60634 }
60635
60636
60637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
60638   void * jresult ;
60639   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60640   SwigDirector_ViewImpl *darg = 0;
60641   Dali::Vector3 result;
60642
60643   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60644   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60645   {
60646     try {
60647       result = (darg)->GetNaturalSize();
60648     } catch (std::out_of_range& e) {
60649       {
60650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60651       };
60652     } catch (std::exception& e) {
60653       {
60654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60655       };
60656     } catch (...) {
60657       {
60658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60659       };
60660     }
60661   }
60662   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60663   return jresult;
60664 }
60665
60666
60667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
60668   void * jresult ;
60669   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60670   SwigDirector_ViewImpl *darg = 0;
60671   Dali::Vector3 result;
60672
60673   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60674   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60675   {
60676     try {
60677       result = (darg)->GetNaturalSizeSwigPublic();
60678     } catch (std::out_of_range& e) {
60679       {
60680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60681       };
60682     } catch (std::exception& e) {
60683       {
60684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60685       };
60686     } catch (...) {
60687       {
60688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60689       };
60690     }
60691   }
60692   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60693   return jresult;
60694 }
60695
60696
60697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
60698   float jresult ;
60699   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60700   Dali::Actor *arg2 = 0 ;
60701   Dali::Dimension::Type arg3 ;
60702   SwigDirector_ViewImpl *darg = 0;
60703   float result;
60704
60705   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60706   arg2 = (Dali::Actor *)jarg2;
60707   if (!arg2) {
60708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60709     return 0;
60710   }
60711   arg3 = (Dali::Dimension::Type)jarg3;
60712   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60713   {
60714     try {
60715       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
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 float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
60736   float jresult ;
60737   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60738   Dali::Actor *arg2 = 0 ;
60739   Dali::Dimension::Type arg3 ;
60740   SwigDirector_ViewImpl *darg = 0;
60741   float result;
60742
60743   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60744   arg2 = (Dali::Actor *)jarg2;
60745   if (!arg2) {
60746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60747     return 0;
60748   }
60749   arg3 = (Dali::Dimension::Type)jarg3;
60750   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60751   {
60752     try {
60753       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
60754     } catch (std::out_of_range& e) {
60755       {
60756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60757       };
60758     } catch (std::exception& e) {
60759       {
60760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60761       };
60762     } catch (...) {
60763       {
60764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60765       };
60766     }
60767   }
60768   jresult = result;
60769   return jresult;
60770 }
60771
60772
60773 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
60774   float jresult ;
60775   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60776   float arg2 ;
60777   SwigDirector_ViewImpl *darg = 0;
60778   float result;
60779
60780   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60781   arg2 = (float)jarg2;
60782   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60783   {
60784     try {
60785       result = (float)(darg)->GetHeightForWidth(arg2);
60786     } catch (std::out_of_range& e) {
60787       {
60788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60789       };
60790     } catch (std::exception& e) {
60791       {
60792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60793       };
60794     } catch (...) {
60795       {
60796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60797       };
60798     }
60799   }
60800   jresult = result;
60801   return jresult;
60802 }
60803
60804
60805 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
60806   float jresult ;
60807   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60808   float arg2 ;
60809   SwigDirector_ViewImpl *darg = 0;
60810   float result;
60811
60812   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60813   arg2 = (float)jarg2;
60814   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60815   {
60816     try {
60817       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
60818     } catch (std::out_of_range& e) {
60819       {
60820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60821       };
60822     } catch (std::exception& e) {
60823       {
60824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60825       };
60826     } catch (...) {
60827       {
60828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60829       };
60830     }
60831   }
60832   jresult = result;
60833   return jresult;
60834 }
60835
60836
60837 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
60838   float jresult ;
60839   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60840   float arg2 ;
60841   SwigDirector_ViewImpl *darg = 0;
60842   float result;
60843
60844   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60845   arg2 = (float)jarg2;
60846   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60847   {
60848     try {
60849       result = (float)(darg)->GetWidthForHeight(arg2);
60850     } catch (std::out_of_range& e) {
60851       {
60852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60853       };
60854     } catch (std::exception& e) {
60855       {
60856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60857       };
60858     } catch (...) {
60859       {
60860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60861       };
60862     }
60863   }
60864   jresult = result;
60865   return jresult;
60866 }
60867
60868
60869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
60870   float jresult ;
60871   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60872   float arg2 ;
60873   SwigDirector_ViewImpl *darg = 0;
60874   float result;
60875
60876   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60877   arg2 = (float)jarg2;
60878   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60879   {
60880     try {
60881       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
60882     } catch (std::out_of_range& e) {
60883       {
60884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60885       };
60886     } catch (std::exception& e) {
60887       {
60888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60889       };
60890     } catch (...) {
60891       {
60892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60893       };
60894     }
60895   }
60896   jresult = result;
60897   return jresult;
60898 }
60899
60900
60901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
60902   unsigned int jresult ;
60903   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60904   Dali::Dimension::Type arg2 ;
60905   SwigDirector_ViewImpl *darg = 0;
60906   bool result;
60907
60908   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60909   arg2 = (Dali::Dimension::Type)jarg2;
60910   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60911   {
60912     try {
60913       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
60914     } catch (std::out_of_range& e) {
60915       {
60916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60917       };
60918     } catch (std::exception& e) {
60919       {
60920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60921       };
60922     } catch (...) {
60923       {
60924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60925       };
60926     }
60927   }
60928   jresult = result;
60929   return jresult;
60930 }
60931
60932
60933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
60934   unsigned int jresult ;
60935   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60936   Dali::Dimension::Type arg2 ;
60937   SwigDirector_ViewImpl *darg = 0;
60938   bool result;
60939
60940   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60941   arg2 = (Dali::Dimension::Type)jarg2;
60942   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60943   {
60944     try {
60945       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
60946     } catch (std::out_of_range& e) {
60947       {
60948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60949       };
60950     } catch (std::exception& e) {
60951       {
60952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60953       };
60954     } catch (...) {
60955       {
60956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60957       };
60958     }
60959   }
60960   jresult = result;
60961   return jresult;
60962 }
60963
60964
60965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
60966   unsigned int jresult ;
60967   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60968   SwigDirector_ViewImpl *darg = 0;
60969   bool result;
60970
60971   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60972   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60973   {
60974     try {
60975       result = (bool)(darg)->RelayoutDependentOnChildren();
60976     } catch (std::out_of_range& e) {
60977       {
60978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60979       };
60980     } catch (std::exception& e) {
60981       {
60982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60983       };
60984     } catch (...) {
60985       {
60986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60987       };
60988     }
60989   }
60990   jresult = result;
60991   return jresult;
60992 }
60993
60994
60995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
60996   unsigned int jresult ;
60997   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60998   SwigDirector_ViewImpl *darg = 0;
60999   bool result;
61000
61001   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61002   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61003   {
61004     try {
61005       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61006     } catch (std::out_of_range& e) {
61007       {
61008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61009       };
61010     } catch (std::exception& e) {
61011       {
61012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61013       };
61014     } catch (...) {
61015       {
61016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61017       };
61018     }
61019   }
61020   jresult = result;
61021   return jresult;
61022 }
61023
61024
61025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61026   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61027   Dali::Dimension::Type arg2 ;
61028   SwigDirector_ViewImpl *darg = 0;
61029
61030   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61031   arg2 = (Dali::Dimension::Type)jarg2;
61032   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61033   {
61034     try {
61035       (darg)->OnCalculateRelayoutSize(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_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61054   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61055   Dali::Dimension::Type arg2 ;
61056   SwigDirector_ViewImpl *darg = 0;
61057
61058   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61059   arg2 = (Dali::Dimension::Type)jarg2;
61060   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61061   {
61062     try {
61063       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61064     } catch (std::out_of_range& e) {
61065       {
61066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61067       };
61068     } catch (std::exception& e) {
61069       {
61070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61071       };
61072     } catch (...) {
61073       {
61074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61075       };
61076     }
61077   }
61078 }
61079
61080
61081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61082   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61083   float arg2 ;
61084   Dali::Dimension::Type arg3 ;
61085   SwigDirector_ViewImpl *darg = 0;
61086
61087   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61088   arg2 = (float)jarg2;
61089   arg3 = (Dali::Dimension::Type)jarg3;
61090   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61091   {
61092     try {
61093       (darg)->OnLayoutNegotiated(arg2,arg3);
61094     } catch (std::out_of_range& e) {
61095       {
61096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61097       };
61098     } catch (std::exception& e) {
61099       {
61100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61101       };
61102     } catch (...) {
61103       {
61104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61105       };
61106     }
61107   }
61108 }
61109
61110
61111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61112   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61113   float arg2 ;
61114   Dali::Dimension::Type arg3 ;
61115   SwigDirector_ViewImpl *darg = 0;
61116
61117   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61118   arg2 = (float)jarg2;
61119   arg3 = (Dali::Dimension::Type)jarg3;
61120   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61121   {
61122     try {
61123       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61124     } catch (std::out_of_range& e) {
61125       {
61126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61127       };
61128     } catch (std::exception& e) {
61129       {
61130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61131       };
61132     } catch (...) {
61133       {
61134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61135       };
61136     }
61137   }
61138 }
61139
61140
61141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
61142   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61143
61144   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61145   {
61146     try {
61147       (arg1)->OnInitialize();
61148     } catch (std::out_of_range& e) {
61149       {
61150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61151       };
61152     } catch (std::exception& e) {
61153       {
61154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61155       };
61156     } catch (...) {
61157       {
61158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61159       };
61160     }
61161   }
61162 }
61163
61164
61165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61166   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61167
61168   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61169   {
61170     try {
61171       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61172     } catch (std::out_of_range& e) {
61173       {
61174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61175       };
61176     } catch (std::exception& e) {
61177       {
61178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61179       };
61180     } catch (...) {
61181       {
61182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61183       };
61184     }
61185   }
61186 }
61187
61188
61189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
61190   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61191   Dali::Actor *arg2 = 0 ;
61192
61193   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61194   arg2 = (Dali::Actor *)jarg2;
61195   if (!arg2) {
61196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61197     return ;
61198   }
61199   {
61200     try {
61201       (arg1)->OnControlChildAdd(*arg2);
61202     } catch (std::out_of_range& e) {
61203       {
61204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61205       };
61206     } catch (std::exception& e) {
61207       {
61208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61209       };
61210     } catch (...) {
61211       {
61212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61213       };
61214     }
61215   }
61216 }
61217
61218
61219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61220   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61221   Dali::Actor *arg2 = 0 ;
61222
61223   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61224   arg2 = (Dali::Actor *)jarg2;
61225   if (!arg2) {
61226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61227     return ;
61228   }
61229   {
61230     try {
61231       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
61232     } catch (std::out_of_range& e) {
61233       {
61234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61235       };
61236     } catch (std::exception& e) {
61237       {
61238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61239       };
61240     } catch (...) {
61241       {
61242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61243       };
61244     }
61245   }
61246 }
61247
61248
61249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
61250   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61251   Dali::Actor *arg2 = 0 ;
61252
61253   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61254   arg2 = (Dali::Actor *)jarg2;
61255   if (!arg2) {
61256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61257     return ;
61258   }
61259   {
61260     try {
61261       (arg1)->OnControlChildRemove(*arg2);
61262     } catch (std::out_of_range& e) {
61263       {
61264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61265       };
61266     } catch (std::exception& e) {
61267       {
61268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61269       };
61270     } catch (...) {
61271       {
61272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61273       };
61274     }
61275   }
61276 }
61277
61278
61279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61280   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61281   Dali::Actor *arg2 = 0 ;
61282
61283   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61284   arg2 = (Dali::Actor *)jarg2;
61285   if (!arg2) {
61286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61287     return ;
61288   }
61289   {
61290     try {
61291       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
61292     } catch (std::out_of_range& e) {
61293       {
61294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61295       };
61296     } catch (std::exception& e) {
61297       {
61298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61299       };
61300     } catch (...) {
61301       {
61302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61303       };
61304     }
61305   }
61306 }
61307
61308
61309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61310   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61311   Dali::Toolkit::StyleManager arg2 ;
61312   Dali::StyleChange::Type arg3 ;
61313   Dali::Toolkit::StyleManager *argp2 ;
61314
61315   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61316   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61317   if (!argp2) {
61318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61319     return ;
61320   }
61321   arg2 = *argp2;
61322   arg3 = (Dali::StyleChange::Type)jarg3;
61323   {
61324     try {
61325       (arg1)->OnStyleChange(arg2,arg3);
61326     } catch (std::out_of_range& e) {
61327       {
61328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61329       };
61330     } catch (std::exception& e) {
61331       {
61332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61333       };
61334     } catch (...) {
61335       {
61336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61337       };
61338     }
61339   }
61340 }
61341
61342
61343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61344   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61345   Dali::Toolkit::StyleManager arg2 ;
61346   Dali::StyleChange::Type arg3 ;
61347   Dali::Toolkit::StyleManager *argp2 ;
61348
61349   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61350   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61351   if (!argp2) {
61352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61353     return ;
61354   }
61355   arg2 = *argp2;
61356   arg3 = (Dali::StyleChange::Type)jarg3;
61357   {
61358     try {
61359       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61360     } catch (std::out_of_range& e) {
61361       {
61362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61363       };
61364     } catch (std::exception& e) {
61365       {
61366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61367       };
61368     } catch (...) {
61369       {
61370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61371       };
61372     }
61373   }
61374 }
61375
61376
61377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
61378   unsigned int jresult ;
61379   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61380   bool result;
61381
61382   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61383   {
61384     try {
61385       result = (bool)(arg1)->OnAccessibilityActivated();
61386     } catch (std::out_of_range& e) {
61387       {
61388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61389       };
61390     } catch (std::exception& e) {
61391       {
61392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61393       };
61394     } catch (...) {
61395       {
61396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61397       };
61398     }
61399   }
61400   jresult = result;
61401   return jresult;
61402 }
61403
61404
61405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
61406   unsigned int jresult ;
61407   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61408   bool result;
61409
61410   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61411   {
61412     try {
61413       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
61414     } catch (std::out_of_range& e) {
61415       {
61416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61417       };
61418     } catch (std::exception& e) {
61419       {
61420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61421       };
61422     } catch (...) {
61423       {
61424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61425       };
61426     }
61427   }
61428   jresult = result;
61429   return jresult;
61430 }
61431
61432
61433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
61434   unsigned int jresult ;
61435   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61436   Dali::PanGesture arg2 ;
61437   Dali::PanGesture *argp2 ;
61438   bool result;
61439
61440   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61441   argp2 = (Dali::PanGesture *)jarg2;
61442   if (!argp2) {
61443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61444     return 0;
61445   }
61446   arg2 = *argp2;
61447   {
61448     try {
61449       result = (bool)(arg1)->OnAccessibilityPan(arg2);
61450     } catch (std::out_of_range& e) {
61451       {
61452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61453       };
61454     } catch (std::exception& e) {
61455       {
61456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61457       };
61458     } catch (...) {
61459       {
61460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61461       };
61462     }
61463   }
61464   jresult = result;
61465   return jresult;
61466 }
61467
61468
61469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61470   unsigned int jresult ;
61471   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61472   Dali::PanGesture arg2 ;
61473   Dali::PanGesture *argp2 ;
61474   bool result;
61475
61476   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61477   argp2 = (Dali::PanGesture *)jarg2;
61478   if (!argp2) {
61479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61480     return 0;
61481   }
61482   arg2 = *argp2;
61483   {
61484     try {
61485       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
61486     } catch (std::out_of_range& e) {
61487       {
61488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61489       };
61490     } catch (std::exception& e) {
61491       {
61492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61493       };
61494     } catch (...) {
61495       {
61496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61497       };
61498     }
61499   }
61500   jresult = result;
61501   return jresult;
61502 }
61503
61504
61505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
61506   unsigned int jresult ;
61507   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61508   Dali::TouchEvent *arg2 = 0 ;
61509   bool result;
61510
61511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61512   arg2 = (Dali::TouchEvent *)jarg2;
61513   if (!arg2) {
61514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61515     return 0;
61516   }
61517   {
61518     try {
61519       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61520     } catch (std::out_of_range& e) {
61521       {
61522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61523       };
61524     } catch (std::exception& e) {
61525       {
61526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61527       };
61528     } catch (...) {
61529       {
61530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61531       };
61532     }
61533   }
61534   jresult = result;
61535   return jresult;
61536 }
61537
61538
61539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61540   unsigned int jresult ;
61541   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61542   Dali::TouchEvent *arg2 = 0 ;
61543   bool result;
61544
61545   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61546   arg2 = (Dali::TouchEvent *)jarg2;
61547   if (!arg2) {
61548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61549     return 0;
61550   }
61551   {
61552     try {
61553       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61554     } catch (std::out_of_range& e) {
61555       {
61556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61557       };
61558     } catch (std::exception& e) {
61559       {
61560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61561       };
61562     } catch (...) {
61563       {
61564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61565       };
61566     }
61567   }
61568   jresult = result;
61569   return jresult;
61570 }
61571
61572
61573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
61574   unsigned int jresult ;
61575   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61576   bool arg2 ;
61577   bool result;
61578
61579   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61580   arg2 = jarg2 ? true : false;
61581   {
61582     try {
61583       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
61584     } catch (std::out_of_range& e) {
61585       {
61586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61587       };
61588     } catch (std::exception& e) {
61589       {
61590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61591       };
61592     } catch (...) {
61593       {
61594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61595       };
61596     }
61597   }
61598   jresult = result;
61599   return jresult;
61600 }
61601
61602
61603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
61604   unsigned int jresult ;
61605   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61606   bool arg2 ;
61607   bool result;
61608
61609   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61610   arg2 = jarg2 ? true : false;
61611   {
61612     try {
61613       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
61614     } catch (std::out_of_range& e) {
61615       {
61616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61617       };
61618     } catch (std::exception& e) {
61619       {
61620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61621       };
61622     } catch (...) {
61623       {
61624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61625       };
61626     }
61627   }
61628   jresult = result;
61629   return jresult;
61630 }
61631
61632
61633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
61634   unsigned int jresult ;
61635   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61636   bool result;
61637
61638   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61639   {
61640     try {
61641       result = (bool)(arg1)->OnAccessibilityZoom();
61642     } catch (std::out_of_range& e) {
61643       {
61644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61645       };
61646     } catch (std::exception& e) {
61647       {
61648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61649       };
61650     } catch (...) {
61651       {
61652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61653       };
61654     }
61655   }
61656   jresult = result;
61657   return jresult;
61658 }
61659
61660
61661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
61662   unsigned int jresult ;
61663   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61664   bool result;
61665
61666   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61667   {
61668     try {
61669       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
61670     } catch (std::out_of_range& e) {
61671       {
61672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61673       };
61674     } catch (std::exception& e) {
61675       {
61676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61677       };
61678     } catch (...) {
61679       {
61680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61681       };
61682     }
61683   }
61684   jresult = result;
61685   return jresult;
61686 }
61687
61688
61689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
61690   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61691
61692   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61693   {
61694     try {
61695       (arg1)->OnKeyInputFocusGained();
61696     } catch (std::out_of_range& e) {
61697       {
61698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61699       };
61700     } catch (std::exception& e) {
61701       {
61702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61703       };
61704     } catch (...) {
61705       {
61706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61707       };
61708     }
61709   }
61710 }
61711
61712
61713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
61714   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61715
61716   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61717   {
61718     try {
61719       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
61720     } catch (std::out_of_range& e) {
61721       {
61722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61723       };
61724     } catch (std::exception& e) {
61725       {
61726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61727       };
61728     } catch (...) {
61729       {
61730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61731       };
61732     }
61733   }
61734 }
61735
61736
61737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
61738   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61739
61740   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61741   {
61742     try {
61743       (arg1)->OnKeyInputFocusLost();
61744     } catch (std::out_of_range& e) {
61745       {
61746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61747       };
61748     } catch (std::exception& e) {
61749       {
61750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61751       };
61752     } catch (...) {
61753       {
61754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61755       };
61756     }
61757   }
61758 }
61759
61760
61761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
61762   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61763
61764   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61765   {
61766     try {
61767       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
61768     } catch (std::out_of_range& e) {
61769       {
61770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61771       };
61772     } catch (std::exception& e) {
61773       {
61774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61775       };
61776     } catch (...) {
61777       {
61778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61779       };
61780     }
61781   }
61782 }
61783
61784
61785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61786   void * jresult ;
61787   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61788   Dali::Actor arg2 ;
61789   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61790   bool arg4 ;
61791   Dali::Actor *argp2 ;
61792   Dali::Actor result;
61793
61794   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61795   argp2 = (Dali::Actor *)jarg2;
61796   if (!argp2) {
61797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61798     return 0;
61799   }
61800   arg2 = *argp2;
61801   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61802   arg4 = jarg4 ? true : false;
61803   {
61804     try {
61805       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61806     } catch (std::out_of_range& e) {
61807       {
61808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61809       };
61810     } catch (std::exception& e) {
61811       {
61812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61813       };
61814     } catch (...) {
61815       {
61816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61817       };
61818     }
61819   }
61820   jresult = new Dali::Actor((const Dali::Actor &)result);
61821   return jresult;
61822 }
61823
61824
61825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61826   void * jresult ;
61827   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61828   Dali::Actor arg2 ;
61829   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61830   bool arg4 ;
61831   Dali::Actor *argp2 ;
61832   Dali::Actor result;
61833
61834   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61835   argp2 = (Dali::Actor *)jarg2;
61836   if (!argp2) {
61837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61838     return 0;
61839   }
61840   arg2 = *argp2;
61841   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61842   arg4 = jarg4 ? true : false;
61843   {
61844     try {
61845       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61846     } catch (std::out_of_range& e) {
61847       {
61848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61849       };
61850     } catch (std::exception& e) {
61851       {
61852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61853       };
61854     } catch (...) {
61855       {
61856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61857       };
61858     }
61859   }
61860   jresult = new Dali::Actor((const Dali::Actor &)result);
61861   return jresult;
61862 }
61863
61864
61865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
61866   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61867   Dali::Actor arg2 ;
61868   Dali::Actor *argp2 ;
61869
61870   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61871   argp2 = (Dali::Actor *)jarg2;
61872   if (!argp2) {
61873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61874     return ;
61875   }
61876   arg2 = *argp2;
61877   {
61878     try {
61879       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
61880     } catch (std::out_of_range& e) {
61881       {
61882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61883       };
61884     } catch (std::exception& e) {
61885       {
61886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61887       };
61888     } catch (...) {
61889       {
61890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61891       };
61892     }
61893   }
61894 }
61895
61896
61897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61898   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61899   Dali::Actor arg2 ;
61900   Dali::Actor *argp2 ;
61901
61902   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61903   argp2 = (Dali::Actor *)jarg2;
61904   if (!argp2) {
61905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61906     return ;
61907   }
61908   arg2 = *argp2;
61909   {
61910     try {
61911       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
61912     } catch (std::out_of_range& e) {
61913       {
61914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61915       };
61916     } catch (std::exception& e) {
61917       {
61918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61919       };
61920     } catch (...) {
61921       {
61922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61923       };
61924     }
61925   }
61926 }
61927
61928
61929 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
61930   unsigned int jresult ;
61931   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61932   bool result;
61933
61934   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61935   {
61936     try {
61937       result = (bool)(arg1)->OnKeyboardEnter();
61938     } catch (std::out_of_range& e) {
61939       {
61940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61941       };
61942     } catch (std::exception& e) {
61943       {
61944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61945       };
61946     } catch (...) {
61947       {
61948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61949       };
61950     }
61951   }
61952   jresult = result;
61953   return jresult;
61954 }
61955
61956
61957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
61958   unsigned int jresult ;
61959   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61960   bool result;
61961
61962   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61963   {
61964     try {
61965       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
61966     } catch (std::out_of_range& e) {
61967       {
61968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61969       };
61970     } catch (std::exception& e) {
61971       {
61972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61973       };
61974     } catch (...) {
61975       {
61976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61977       };
61978     }
61979   }
61980   jresult = result;
61981   return jresult;
61982 }
61983
61984
61985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
61986   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61987   Dali::PinchGesture *arg2 = 0 ;
61988
61989   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61990   arg2 = (Dali::PinchGesture *)jarg2;
61991   if (!arg2) {
61992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
61993     return ;
61994   }
61995   {
61996     try {
61997       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
61998     } catch (std::out_of_range& e) {
61999       {
62000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62001       };
62002     } catch (std::exception& e) {
62003       {
62004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62005       };
62006     } catch (...) {
62007       {
62008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62009       };
62010     }
62011   }
62012 }
62013
62014
62015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62016   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62017   Dali::PinchGesture *arg2 = 0 ;
62018
62019   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62020   arg2 = (Dali::PinchGesture *)jarg2;
62021   if (!arg2) {
62022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62023     return ;
62024   }
62025   {
62026     try {
62027       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62028     } catch (std::out_of_range& e) {
62029       {
62030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62031       };
62032     } catch (std::exception& e) {
62033       {
62034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62035       };
62036     } catch (...) {
62037       {
62038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62039       };
62040     }
62041   }
62042 }
62043
62044
62045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62046   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62047   Dali::PanGesture *arg2 = 0 ;
62048
62049   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62050   arg2 = (Dali::PanGesture *)jarg2;
62051   if (!arg2) {
62052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62053     return ;
62054   }
62055   {
62056     try {
62057       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62058     } catch (std::out_of_range& e) {
62059       {
62060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62061       };
62062     } catch (std::exception& e) {
62063       {
62064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62065       };
62066     } catch (...) {
62067       {
62068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62069       };
62070     }
62071   }
62072 }
62073
62074
62075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62076   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62077   Dali::PanGesture *arg2 = 0 ;
62078
62079   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62080   arg2 = (Dali::PanGesture *)jarg2;
62081   if (!arg2) {
62082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62083     return ;
62084   }
62085   {
62086     try {
62087       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62088     } catch (std::out_of_range& e) {
62089       {
62090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62091       };
62092     } catch (std::exception& e) {
62093       {
62094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62095       };
62096     } catch (...) {
62097       {
62098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62099       };
62100     }
62101   }
62102 }
62103
62104
62105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62106   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62107   Dali::TapGesture *arg2 = 0 ;
62108
62109   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62110   arg2 = (Dali::TapGesture *)jarg2;
62111   if (!arg2) {
62112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62113     return ;
62114   }
62115   {
62116     try {
62117       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
62118     } catch (std::out_of_range& e) {
62119       {
62120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62121       };
62122     } catch (std::exception& e) {
62123       {
62124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62125       };
62126     } catch (...) {
62127       {
62128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62129       };
62130     }
62131   }
62132 }
62133
62134
62135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62136   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62137   Dali::TapGesture *arg2 = 0 ;
62138
62139   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62140   arg2 = (Dali::TapGesture *)jarg2;
62141   if (!arg2) {
62142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62143     return ;
62144   }
62145   {
62146     try {
62147       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
62148     } catch (std::out_of_range& e) {
62149       {
62150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62151       };
62152     } catch (std::exception& e) {
62153       {
62154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62155       };
62156     } catch (...) {
62157       {
62158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62159       };
62160     }
62161   }
62162 }
62163
62164
62165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62166   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62167   Dali::LongPressGesture *arg2 = 0 ;
62168
62169   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62170   arg2 = (Dali::LongPressGesture *)jarg2;
62171   if (!arg2) {
62172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62173     return ;
62174   }
62175   {
62176     try {
62177       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62178     } catch (std::out_of_range& e) {
62179       {
62180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62181       };
62182     } catch (std::exception& e) {
62183       {
62184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62185       };
62186     } catch (...) {
62187       {
62188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62189       };
62190     }
62191   }
62192 }
62193
62194
62195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62196   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62197   Dali::LongPressGesture *arg2 = 0 ;
62198
62199   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62200   arg2 = (Dali::LongPressGesture *)jarg2;
62201   if (!arg2) {
62202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62203     return ;
62204   }
62205   {
62206     try {
62207       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62208     } catch (std::out_of_range& e) {
62209       {
62210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62211       };
62212     } catch (std::exception& e) {
62213       {
62214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62215       };
62216     } catch (...) {
62217       {
62218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62219       };
62220     }
62221   }
62222 }
62223
62224
62225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62226   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62227   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62228   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62229
62230   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62231   arg2 = (Dali::SlotObserver *)jarg2;
62232   arg3 = (Dali::CallbackBase *)jarg3;
62233   {
62234     try {
62235       (arg1)->SignalConnected(arg2,arg3);
62236     } catch (std::out_of_range& e) {
62237       {
62238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62239       };
62240     } catch (std::exception& e) {
62241       {
62242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62243       };
62244     } catch (...) {
62245       {
62246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62247       };
62248     }
62249   }
62250 }
62251
62252
62253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62254   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62255   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62256   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62257
62258   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62259   arg2 = (Dali::SlotObserver *)jarg2;
62260   arg3 = (Dali::CallbackBase *)jarg3;
62261   {
62262     try {
62263       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
62264     } catch (std::out_of_range& e) {
62265       {
62266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62267       };
62268     } catch (std::exception& e) {
62269       {
62270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62271       };
62272     } catch (...) {
62273       {
62274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62275       };
62276     }
62277   }
62278 }
62279
62280
62281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
62282   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62283   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62284   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62285
62286   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62287   arg2 = (Dali::SlotObserver *)jarg2;
62288   arg3 = (Dali::CallbackBase *)jarg3;
62289   {
62290     try {
62291       (arg1)->SignalDisconnected(arg2,arg3);
62292     } catch (std::out_of_range& e) {
62293       {
62294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62295       };
62296     } catch (std::exception& e) {
62297       {
62298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62299       };
62300     } catch (...) {
62301       {
62302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62303       };
62304     }
62305   }
62306 }
62307
62308
62309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62310   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62311   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62312   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62313
62314   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62315   arg2 = (Dali::SlotObserver *)jarg2;
62316   arg3 = (Dali::CallbackBase *)jarg3;
62317   {
62318     try {
62319       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
62320     } catch (std::out_of_range& e) {
62321       {
62322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62323       };
62324     } catch (std::exception& e) {
62325       {
62326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62327       };
62328     } catch (...) {
62329       {
62330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62331       };
62332     }
62333   }
62334 }
62335
62336
62337 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) {
62338   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62339   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62340   if (director) {
62341     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);
62342   }
62343 }
62344
62345
62346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
62347   void * jresult ;
62348   Dali::Toolkit::Control *arg1 = 0 ;
62349   Dali::Toolkit::Internal::Control *result = 0 ;
62350
62351   arg1 = (Dali::Toolkit::Control *)jarg1;
62352   if (!arg1) {
62353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62354     return 0;
62355   }
62356   {
62357     try {
62358       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62359     } catch (std::out_of_range& e) {
62360       {
62361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62362       };
62363     } catch (std::exception& e) {
62364       {
62365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62366       };
62367     } catch (...) {
62368       {
62369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62370       };
62371     }
62372   }
62373   jresult = (void *)result;
62374   return jresult;
62375 }
62376
62377
62378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
62379   int jresult ;
62380   int result;
62381
62382   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
62383   jresult = (int)result;
62384   return jresult;
62385 }
62386
62387
62388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
62389   int jresult ;
62390   int result;
62391
62392   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
62393   jresult = (int)result;
62394   return jresult;
62395 }
62396
62397
62398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
62399   int jresult ;
62400   int result;
62401
62402   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
62403   jresult = (int)result;
62404   return jresult;
62405 }
62406
62407
62408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
62409   int jresult ;
62410   int result;
62411
62412   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
62413   jresult = (int)result;
62414   return jresult;
62415 }
62416
62417
62418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
62419   int jresult ;
62420   int result;
62421
62422   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
62423   jresult = (int)result;
62424   return jresult;
62425 }
62426
62427
62428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
62429   void * jresult ;
62430   Dali::Toolkit::Control::Property *result = 0 ;
62431
62432   {
62433     try {
62434       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
62435     } catch (std::out_of_range& e) {
62436       {
62437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62438       };
62439     } catch (std::exception& e) {
62440       {
62441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62442       };
62443     } catch (...) {
62444       {
62445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62446       };
62447     }
62448   }
62449   jresult = (void *)result;
62450   return jresult;
62451 }
62452
62453
62454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
62455   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
62456
62457   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
62458   {
62459     try {
62460       delete arg1;
62461     } catch (std::out_of_range& e) {
62462       {
62463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62464       };
62465     } catch (std::exception& e) {
62466       {
62467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62468       };
62469     } catch (...) {
62470       {
62471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62472       };
62473     }
62474   }
62475 }
62476
62477
62478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
62479   void * jresult ;
62480   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
62481
62482   {
62483     try {
62484       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
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_delete_View_KeyboardFocus(void * jarg1) {
62505   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
62506
62507   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
62508   {
62509     try {
62510       delete arg1;
62511     } catch (std::out_of_range& e) {
62512       {
62513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62514       };
62515     } catch (std::exception& e) {
62516       {
62517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62518       };
62519     } catch (...) {
62520       {
62521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62522       };
62523     }
62524   }
62525 }
62526
62527
62528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
62529   void * jresult ;
62530   Dali::Toolkit::Control result;
62531
62532   {
62533     try {
62534       result = Dali::Toolkit::Control::New();
62535     } catch (std::out_of_range& e) {
62536       {
62537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62538       };
62539     } catch (std::exception& e) {
62540       {
62541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62542       };
62543     } catch (...) {
62544       {
62545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62546       };
62547     }
62548   }
62549   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62550   return jresult;
62551 }
62552
62553
62554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
62555   void * jresult ;
62556   Dali::Toolkit::Control *result = 0 ;
62557
62558   {
62559     try {
62560       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
62561     } catch (std::out_of_range& e) {
62562       {
62563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62564       };
62565     } catch (std::exception& e) {
62566       {
62567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62568       };
62569     } catch (...) {
62570       {
62571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62572       };
62573     }
62574   }
62575   jresult = (void *)result;
62576   return jresult;
62577 }
62578
62579
62580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
62581   void * jresult ;
62582   Dali::Toolkit::Control *arg1 = 0 ;
62583   Dali::Toolkit::Control *result = 0 ;
62584
62585   arg1 = (Dali::Toolkit::Control *)jarg1;
62586   if (!arg1) {
62587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62588     return 0;
62589   }
62590   {
62591     try {
62592       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
62593     } catch (std::out_of_range& e) {
62594       {
62595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62596       };
62597     } catch (std::exception& e) {
62598       {
62599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62600       };
62601     } catch (...) {
62602       {
62603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62604       };
62605     }
62606   }
62607   jresult = (void *)result;
62608   return jresult;
62609 }
62610
62611
62612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
62613   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62614
62615   arg1 = (Dali::Toolkit::Control *)jarg1;
62616   {
62617     try {
62618       delete arg1;
62619     } catch (std::out_of_range& e) {
62620       {
62621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62622       };
62623     } catch (std::exception& e) {
62624       {
62625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62626       };
62627     } catch (...) {
62628       {
62629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62630       };
62631     }
62632   }
62633 }
62634
62635
62636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
62637   void * jresult ;
62638   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62639   Dali::Toolkit::Control *arg2 = 0 ;
62640   Dali::Toolkit::Control *result = 0 ;
62641
62642   arg1 = (Dali::Toolkit::Control *)jarg1;
62643   arg2 = (Dali::Toolkit::Control *)jarg2;
62644   if (!arg2) {
62645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62646     return 0;
62647   }
62648   {
62649     try {
62650       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
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 = (void *)result;
62666   return jresult;
62667 }
62668
62669
62670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
62671   void * jresult ;
62672   Dali::BaseHandle arg1 ;
62673   Dali::BaseHandle *argp1 ;
62674   Dali::Toolkit::Control result;
62675
62676   argp1 = (Dali::BaseHandle *)jarg1;
62677   if (!argp1) {
62678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62679     return 0;
62680   }
62681   arg1 = *argp1;
62682   {
62683     try {
62684       result = Dali::Toolkit::Control::DownCast(arg1);
62685     } catch (std::out_of_range& e) {
62686       {
62687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62688       };
62689     } catch (std::exception& e) {
62690       {
62691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62692       };
62693     } catch (...) {
62694       {
62695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62696       };
62697     }
62698   }
62699   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62700   return jresult;
62701 }
62702
62703
62704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
62705   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62706
62707   arg1 = (Dali::Toolkit::Control *)jarg1;
62708   {
62709     try {
62710       (arg1)->SetKeyInputFocus();
62711     } catch (std::out_of_range& e) {
62712       {
62713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62714       };
62715     } catch (std::exception& e) {
62716       {
62717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62718       };
62719     } catch (...) {
62720       {
62721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62722       };
62723     }
62724   }
62725 }
62726
62727
62728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
62729   unsigned int jresult ;
62730   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62731   bool result;
62732
62733   arg1 = (Dali::Toolkit::Control *)jarg1;
62734   {
62735     try {
62736       result = (bool)(arg1)->HasKeyInputFocus();
62737     } catch (std::out_of_range& e) {
62738       {
62739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62740       };
62741     } catch (std::exception& e) {
62742       {
62743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62744       };
62745     } catch (...) {
62746       {
62747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62748       };
62749     }
62750   }
62751   jresult = result;
62752   return jresult;
62753 }
62754
62755
62756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
62757   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62758
62759   arg1 = (Dali::Toolkit::Control *)jarg1;
62760   {
62761     try {
62762       (arg1)->ClearKeyInputFocus();
62763     } catch (std::out_of_range& e) {
62764       {
62765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62766       };
62767     } catch (std::exception& e) {
62768       {
62769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62770       };
62771     } catch (...) {
62772       {
62773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62774       };
62775     }
62776   }
62777 }
62778
62779
62780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
62781   void * jresult ;
62782   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62783   Dali::PinchGestureDetector result;
62784
62785   arg1 = (Dali::Toolkit::Control *)jarg1;
62786   {
62787     try {
62788       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
62789     } catch (std::out_of_range& e) {
62790       {
62791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62792       };
62793     } catch (std::exception& e) {
62794       {
62795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62796       };
62797     } catch (...) {
62798       {
62799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62800       };
62801     }
62802   }
62803   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
62804   return jresult;
62805 }
62806
62807
62808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
62809   void * jresult ;
62810   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62811   Dali::PanGestureDetector result;
62812
62813   arg1 = (Dali::Toolkit::Control *)jarg1;
62814   {
62815     try {
62816       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
62817     } catch (std::out_of_range& e) {
62818       {
62819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62820       };
62821     } catch (std::exception& e) {
62822       {
62823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62824       };
62825     } catch (...) {
62826       {
62827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62828       };
62829     }
62830   }
62831   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
62832   return jresult;
62833 }
62834
62835
62836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
62837   void * jresult ;
62838   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62839   Dali::TapGestureDetector result;
62840
62841   arg1 = (Dali::Toolkit::Control *)jarg1;
62842   {
62843     try {
62844       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
62845     } catch (std::out_of_range& e) {
62846       {
62847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62848       };
62849     } catch (std::exception& e) {
62850       {
62851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62852       };
62853     } catch (...) {
62854       {
62855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62856       };
62857     }
62858   }
62859   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
62860   return jresult;
62861 }
62862
62863
62864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
62865   void * jresult ;
62866   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62867   Dali::LongPressGestureDetector result;
62868
62869   arg1 = (Dali::Toolkit::Control *)jarg1;
62870   {
62871     try {
62872       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
62873     } catch (std::out_of_range& e) {
62874       {
62875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62876       };
62877     } catch (std::exception& e) {
62878       {
62879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62880       };
62881     } catch (...) {
62882       {
62883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62884       };
62885     }
62886   }
62887   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
62888   return jresult;
62889 }
62890
62891
62892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
62893   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62894   std::string *arg2 = 0 ;
62895
62896   arg1 = (Dali::Toolkit::Control *)jarg1;
62897   if (!jarg2) {
62898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62899     return ;
62900   }
62901   std::string arg2_str(jarg2);
62902   arg2 = &arg2_str;
62903   {
62904     try {
62905       (arg1)->SetStyleName((std::string const &)*arg2);
62906     } catch (std::out_of_range& e) {
62907       {
62908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62909       };
62910     } catch (std::exception& e) {
62911       {
62912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62913       };
62914     } catch (...) {
62915       {
62916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62917       };
62918     }
62919   }
62920
62921   //argout typemap for const std::string&
62922
62923 }
62924
62925
62926 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
62927   char * jresult ;
62928   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62929   std::string *result = 0 ;
62930
62931   arg1 = (Dali::Toolkit::Control *)jarg1;
62932   {
62933     try {
62934       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
62935     } catch (std::out_of_range& e) {
62936       {
62937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62938       };
62939     } catch (std::exception& e) {
62940       {
62941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62942       };
62943     } catch (...) {
62944       {
62945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62946       };
62947     }
62948   }
62949   jresult = SWIG_csharp_string_callback(result->c_str());
62950   return jresult;
62951 }
62952
62953
62954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
62955   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62956   Dali::Vector4 *arg2 = 0 ;
62957
62958   arg1 = (Dali::Toolkit::Control *)jarg1;
62959   arg2 = (Dali::Vector4 *)jarg2;
62960   if (!arg2) {
62961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
62962     return ;
62963   }
62964   {
62965     try {
62966       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
62967     } catch (std::out_of_range& e) {
62968       {
62969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62970       };
62971     } catch (std::exception& e) {
62972       {
62973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62974       };
62975     } catch (...) {
62976       {
62977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62978       };
62979     }
62980   }
62981 }
62982
62983
62984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
62985   void * jresult ;
62986   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62987   Dali::Vector4 result;
62988
62989   arg1 = (Dali::Toolkit::Control *)jarg1;
62990   {
62991     try {
62992       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
62993     } catch (std::out_of_range& e) {
62994       {
62995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62996       };
62997     } catch (std::exception& e) {
62998       {
62999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63000       };
63001     } catch (...) {
63002       {
63003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63004       };
63005     }
63006   }
63007   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63008   return jresult;
63009 }
63010
63011
63012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
63013   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63014   Dali::Image arg2 ;
63015   Dali::Image *argp2 ;
63016
63017   arg1 = (Dali::Toolkit::Control *)jarg1;
63018   argp2 = (Dali::Image *)jarg2;
63019   if (!argp2) {
63020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63021     return ;
63022   }
63023   arg2 = *argp2;
63024   {
63025     try {
63026       (arg1)->SetBackgroundImage(arg2);
63027     } catch (std::out_of_range& e) {
63028       {
63029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63030       };
63031     } catch (std::exception& e) {
63032       {
63033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63034       };
63035     } catch (...) {
63036       {
63037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63038       };
63039     }
63040   }
63041 }
63042
63043
63044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
63045   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63046
63047   arg1 = (Dali::Toolkit::Control *)jarg1;
63048   {
63049     try {
63050       (arg1)->ClearBackground();
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_View_KeyEventSignal(void * jarg1) {
63069   void * jresult ;
63070   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63071   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63072
63073   arg1 = (Dali::Toolkit::Control *)jarg1;
63074   {
63075     try {
63076       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63077     } catch (std::out_of_range& e) {
63078       {
63079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63080       };
63081     } catch (std::exception& e) {
63082       {
63083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63084       };
63085     } catch (...) {
63086       {
63087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63088       };
63089     }
63090   }
63091   jresult = (void *)result;
63092   return jresult;
63093 }
63094
63095
63096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
63097   void * jresult ;
63098   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63099   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63100
63101   arg1 = (Dali::Toolkit::Control *)jarg1;
63102   {
63103     try {
63104       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63105     } catch (std::out_of_range& e) {
63106       {
63107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63108       };
63109     } catch (std::exception& e) {
63110       {
63111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63112       };
63113     } catch (...) {
63114       {
63115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63116       };
63117     }
63118   }
63119   jresult = (void *)result;
63120   return jresult;
63121 }
63122
63123
63124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
63125   void * jresult ;
63126   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63127   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63128
63129   arg1 = (Dali::Toolkit::Control *)jarg1;
63130   {
63131     try {
63132       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63133     } catch (std::out_of_range& e) {
63134       {
63135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63136       };
63137     } catch (std::exception& e) {
63138       {
63139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63140       };
63141     } catch (...) {
63142       {
63143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63144       };
63145     }
63146   }
63147   jresult = (void *)result;
63148   return jresult;
63149 }
63150
63151
63152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
63153   void * jresult ;
63154   Dali::Toolkit::Internal::Control *arg1 = 0 ;
63155   Dali::Toolkit::Control *result = 0 ;
63156
63157   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63158   if (!arg1) {
63159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
63160     return 0;
63161   }
63162   {
63163     try {
63164       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
63165     } catch (std::out_of_range& e) {
63166       {
63167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63168       };
63169     } catch (std::exception& e) {
63170       {
63171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63172       };
63173     } catch (...) {
63174       {
63175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63176       };
63177     }
63178   }
63179   jresult = (void *)result;
63180   return jresult;
63181 }
63182
63183
63184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
63185   void * jresult ;
63186   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
63187
63188   {
63189     try {
63190       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
63191     } catch (std::out_of_range& e) {
63192       {
63193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63194       };
63195     } catch (std::exception& e) {
63196       {
63197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63198       };
63199     } catch (...) {
63200       {
63201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63202       };
63203     }
63204   }
63205   jresult = (void *)result;
63206   return jresult;
63207 }
63208
63209
63210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
63211   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63212
63213   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63214   {
63215     try {
63216       delete arg1;
63217     } catch (std::out_of_range& e) {
63218       {
63219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63220       };
63221     } catch (std::exception& e) {
63222       {
63223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63224       };
63225     } catch (...) {
63226       {
63227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63228       };
63229     }
63230   }
63231 }
63232
63233
63234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
63235   void * jresult ;
63236   Dali::Toolkit::KeyInputFocusManager result;
63237
63238   {
63239     try {
63240       result = Dali::Toolkit::KeyInputFocusManager::Get();
63241     } catch (std::out_of_range& e) {
63242       {
63243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63244       };
63245     } catch (std::exception& e) {
63246       {
63247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63248       };
63249     } catch (...) {
63250       {
63251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63252       };
63253     }
63254   }
63255   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
63256   return jresult;
63257 }
63258
63259
63260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
63261   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63262   Dali::Toolkit::Control arg2 ;
63263   Dali::Toolkit::Control *argp2 ;
63264
63265   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63266   argp2 = (Dali::Toolkit::Control *)jarg2;
63267   if (!argp2) {
63268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63269     return ;
63270   }
63271   arg2 = *argp2;
63272   {
63273     try {
63274       (arg1)->SetFocus(arg2);
63275     } catch (std::out_of_range& e) {
63276       {
63277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63278       };
63279     } catch (std::exception& e) {
63280       {
63281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63282       };
63283     } catch (...) {
63284       {
63285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63286       };
63287     }
63288   }
63289 }
63290
63291
63292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
63293   void * jresult ;
63294   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63295   Dali::Toolkit::Control result;
63296
63297   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63298   {
63299     try {
63300       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
63301     } catch (std::out_of_range& e) {
63302       {
63303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63304       };
63305     } catch (std::exception& e) {
63306       {
63307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63308       };
63309     } catch (...) {
63310       {
63311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63312       };
63313     }
63314   }
63315   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63316   return jresult;
63317 }
63318
63319
63320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
63321   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63322   Dali::Toolkit::Control arg2 ;
63323   Dali::Toolkit::Control *argp2 ;
63324
63325   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63326   argp2 = (Dali::Toolkit::Control *)jarg2;
63327   if (!argp2) {
63328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63329     return ;
63330   }
63331   arg2 = *argp2;
63332   {
63333     try {
63334       (arg1)->RemoveFocus(arg2);
63335     } catch (std::out_of_range& e) {
63336       {
63337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63338       };
63339     } catch (std::exception& e) {
63340       {
63341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63342       };
63343     } catch (...) {
63344       {
63345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63346       };
63347     }
63348   }
63349 }
63350
63351
63352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
63353   void * jresult ;
63354   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63355   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
63356
63357   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63358   {
63359     try {
63360       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
63361     } catch (std::out_of_range& e) {
63362       {
63363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63364       };
63365     } catch (std::exception& e) {
63366       {
63367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63368       };
63369     } catch (...) {
63370       {
63371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63372       };
63373     }
63374   }
63375   jresult = (void *)result;
63376   return jresult;
63377 }
63378
63379
63380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
63381   void * jresult ;
63382   Dali::Toolkit::Alignment::Padding *result = 0 ;
63383
63384   {
63385     try {
63386       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
63387     } catch (std::out_of_range& e) {
63388       {
63389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63390       };
63391     } catch (std::exception& e) {
63392       {
63393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63394       };
63395     } catch (...) {
63396       {
63397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63398       };
63399     }
63400   }
63401   jresult = (void *)result;
63402   return jresult;
63403 }
63404
63405
63406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
63407   void * jresult ;
63408   float arg1 ;
63409   float arg2 ;
63410   float arg3 ;
63411   float arg4 ;
63412   Dali::Toolkit::Alignment::Padding *result = 0 ;
63413
63414   arg1 = (float)jarg1;
63415   arg2 = (float)jarg2;
63416   arg3 = (float)jarg3;
63417   arg4 = (float)jarg4;
63418   {
63419     try {
63420       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
63421     } catch (std::out_of_range& e) {
63422       {
63423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63424       };
63425     } catch (std::exception& e) {
63426       {
63427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63428       };
63429     } catch (...) {
63430       {
63431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63432       };
63433     }
63434   }
63435   jresult = (void *)result;
63436   return jresult;
63437 }
63438
63439
63440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
63441   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63442   float arg2 ;
63443
63444   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63445   arg2 = (float)jarg2;
63446   if (arg1) (arg1)->left = arg2;
63447 }
63448
63449
63450 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
63451   float jresult ;
63452   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63453   float result;
63454
63455   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63456   result = (float) ((arg1)->left);
63457   jresult = result;
63458   return jresult;
63459 }
63460
63461
63462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
63463   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63464   float arg2 ;
63465
63466   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63467   arg2 = (float)jarg2;
63468   if (arg1) (arg1)->right = arg2;
63469 }
63470
63471
63472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
63473   float jresult ;
63474   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63475   float result;
63476
63477   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63478   result = (float) ((arg1)->right);
63479   jresult = result;
63480   return jresult;
63481 }
63482
63483
63484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
63485   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63486   float arg2 ;
63487
63488   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63489   arg2 = (float)jarg2;
63490   if (arg1) (arg1)->top = arg2;
63491 }
63492
63493
63494 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
63495   float jresult ;
63496   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63497   float result;
63498
63499   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63500   result = (float) ((arg1)->top);
63501   jresult = result;
63502   return jresult;
63503 }
63504
63505
63506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
63507   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63508   float arg2 ;
63509
63510   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63511   arg2 = (float)jarg2;
63512   if (arg1) (arg1)->bottom = arg2;
63513 }
63514
63515
63516 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
63517   float jresult ;
63518   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63519   float result;
63520
63521   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63522   result = (float) ((arg1)->bottom);
63523   jresult = result;
63524   return jresult;
63525 }
63526
63527
63528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
63529   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63530
63531   arg1 = (Dali::Toolkit::Alignment::Padding *)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_new_Alignment__SWIG_0() {
63553   void * jresult ;
63554   Dali::Toolkit::Alignment *result = 0 ;
63555
63556   {
63557     try {
63558       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
63559     } catch (std::out_of_range& e) {
63560       {
63561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63562       };
63563     } catch (std::exception& e) {
63564       {
63565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63566       };
63567     } catch (...) {
63568       {
63569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63570       };
63571     }
63572   }
63573   jresult = (void *)result;
63574   return jresult;
63575 }
63576
63577
63578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
63579   void * jresult ;
63580   Dali::Toolkit::Alignment::Type arg1 ;
63581   Dali::Toolkit::Alignment::Type arg2 ;
63582   Dali::Toolkit::Alignment result;
63583
63584   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63585   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63586   {
63587     try {
63588       result = Dali::Toolkit::Alignment::New(arg1,arg2);
63589     } catch (std::out_of_range& e) {
63590       {
63591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63592       };
63593     } catch (std::exception& e) {
63594       {
63595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63596       };
63597     } catch (...) {
63598       {
63599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63600       };
63601     }
63602   }
63603   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63604   return jresult;
63605 }
63606
63607
63608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
63609   void * jresult ;
63610   Dali::Toolkit::Alignment::Type arg1 ;
63611   Dali::Toolkit::Alignment result;
63612
63613   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63614   {
63615     try {
63616       result = Dali::Toolkit::Alignment::New(arg1);
63617     } catch (std::out_of_range& e) {
63618       {
63619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63620       };
63621     } catch (std::exception& e) {
63622       {
63623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63624       };
63625     } catch (...) {
63626       {
63627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63628       };
63629     }
63630   }
63631   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63632   return jresult;
63633 }
63634
63635
63636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
63637   void * jresult ;
63638   Dali::Toolkit::Alignment result;
63639
63640   {
63641     try {
63642       result = Dali::Toolkit::Alignment::New();
63643     } catch (std::out_of_range& e) {
63644       {
63645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63646       };
63647     } catch (std::exception& e) {
63648       {
63649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63650       };
63651     } catch (...) {
63652       {
63653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63654       };
63655     }
63656   }
63657   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63658   return jresult;
63659 }
63660
63661
63662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
63663   void * jresult ;
63664   Dali::Toolkit::Alignment *arg1 = 0 ;
63665   Dali::Toolkit::Alignment *result = 0 ;
63666
63667   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63668   if (!arg1) {
63669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63670     return 0;
63671   }
63672   {
63673     try {
63674       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
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 = (void *)result;
63690   return jresult;
63691 }
63692
63693
63694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
63695   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63696
63697   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63698   {
63699     try {
63700       delete arg1;
63701     } catch (std::out_of_range& e) {
63702       {
63703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63704       };
63705     } catch (std::exception& e) {
63706       {
63707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63708       };
63709     } catch (...) {
63710       {
63711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63712       };
63713     }
63714   }
63715 }
63716
63717
63718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
63719   void * jresult ;
63720   Dali::BaseHandle arg1 ;
63721   Dali::BaseHandle *argp1 ;
63722   Dali::Toolkit::Alignment result;
63723
63724   argp1 = (Dali::BaseHandle *)jarg1;
63725   if (!argp1) {
63726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63727     return 0;
63728   }
63729   arg1 = *argp1;
63730   {
63731     try {
63732       result = Dali::Toolkit::Alignment::DownCast(arg1);
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 = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63748   return jresult;
63749 }
63750
63751
63752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
63753   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63754   Dali::Toolkit::Alignment::Type arg2 ;
63755
63756   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63757   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63758   {
63759     try {
63760       (arg1)->SetAlignmentType(arg2);
63761     } catch (std::out_of_range& e) {
63762       {
63763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63764       };
63765     } catch (std::exception& e) {
63766       {
63767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63768       };
63769     } catch (...) {
63770       {
63771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63772       };
63773     }
63774   }
63775 }
63776
63777
63778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
63779   int jresult ;
63780   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63781   Dali::Toolkit::Alignment::Type result;
63782
63783   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63784   {
63785     try {
63786       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
63787     } catch (std::out_of_range& e) {
63788       {
63789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63790       };
63791     } catch (std::exception& e) {
63792       {
63793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63794       };
63795     } catch (...) {
63796       {
63797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63798       };
63799     }
63800   }
63801   jresult = (int)result;
63802   return jresult;
63803 }
63804
63805
63806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
63807   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63808   Dali::Toolkit::Alignment::Scaling arg2 ;
63809
63810   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63811   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
63812   {
63813     try {
63814       (arg1)->SetScaling(arg2);
63815     } catch (std::out_of_range& e) {
63816       {
63817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63818       };
63819     } catch (std::exception& e) {
63820       {
63821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63822       };
63823     } catch (...) {
63824       {
63825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63826       };
63827     }
63828   }
63829 }
63830
63831
63832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
63833   int jresult ;
63834   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63835   Dali::Toolkit::Alignment::Scaling result;
63836
63837   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63838   {
63839     try {
63840       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
63841     } catch (std::out_of_range& e) {
63842       {
63843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63844       };
63845     } catch (std::exception& e) {
63846       {
63847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63848       };
63849     } catch (...) {
63850       {
63851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63852       };
63853     }
63854   }
63855   jresult = (int)result;
63856   return jresult;
63857 }
63858
63859
63860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
63861   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63862   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
63863
63864   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63865   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
63866   if (!arg2) {
63867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
63868     return ;
63869   }
63870   {
63871     try {
63872       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
63873     } catch (std::out_of_range& e) {
63874       {
63875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63876       };
63877     } catch (std::exception& e) {
63878       {
63879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63880       };
63881     } catch (...) {
63882       {
63883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63884       };
63885     }
63886   }
63887 }
63888
63889
63890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
63891   void * jresult ;
63892   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63893   Dali::Toolkit::Alignment::Padding *result = 0 ;
63894
63895   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63896   {
63897     try {
63898       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
63899     } catch (std::out_of_range& e) {
63900       {
63901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63902       };
63903     } catch (std::exception& e) {
63904       {
63905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63906       };
63907     } catch (...) {
63908       {
63909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63910       };
63911     }
63912   }
63913   jresult = (void *)result;
63914   return jresult;
63915 }
63916
63917
63918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
63919   void * jresult ;
63920   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63921   Dali::Toolkit::Alignment *arg2 = 0 ;
63922   Dali::Toolkit::Alignment *result = 0 ;
63923
63924   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63925   arg2 = (Dali::Toolkit::Alignment *)jarg2;
63926   if (!arg2) {
63927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63928     return 0;
63929   }
63930   {
63931     try {
63932       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
63933     } catch (std::out_of_range& e) {
63934       {
63935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63936       };
63937     } catch (std::exception& e) {
63938       {
63939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63940       };
63941     } catch (...) {
63942       {
63943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63944       };
63945     }
63946   }
63947   jresult = (void *)result;
63948   return jresult;
63949 }
63950
63951
63952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
63953   int jresult ;
63954   int result;
63955
63956   result = (int)Dali::Toolkit::Button::Property::DISABLED;
63957   jresult = (int)result;
63958   return jresult;
63959 }
63960
63961
63962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
63963   int jresult ;
63964   int result;
63965
63966   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
63967   jresult = (int)result;
63968   return jresult;
63969 }
63970
63971
63972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
63973   int jresult ;
63974   int result;
63975
63976   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
63977   jresult = (int)result;
63978   return jresult;
63979 }
63980
63981
63982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
63983   int jresult ;
63984   int result;
63985
63986   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
63987   jresult = (int)result;
63988   return jresult;
63989 }
63990
63991
63992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
63993   int jresult ;
63994   int result;
63995
63996   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
63997   jresult = (int)result;
63998   return jresult;
63999 }
64000
64001
64002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
64003   int jresult ;
64004   int result;
64005
64006   result = (int)Dali::Toolkit::Button::Property::SELECTED;
64007   jresult = (int)result;
64008   return jresult;
64009 }
64010
64011
64012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
64013   int jresult ;
64014   int result;
64015
64016   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
64017   jresult = (int)result;
64018   return jresult;
64019 }
64020
64021
64022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
64023   int jresult ;
64024   int result;
64025
64026   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
64027   jresult = (int)result;
64028   return jresult;
64029 }
64030
64031
64032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
64033   int jresult ;
64034   int result;
64035
64036   result = (int)Dali::Toolkit::Button::Property::LABEL;
64037   jresult = (int)result;
64038   return jresult;
64039 }
64040
64041
64042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
64043   int jresult ;
64044   int result;
64045
64046   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
64047   jresult = (int)result;
64048   return jresult;
64049 }
64050
64051
64052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
64053   void * jresult ;
64054   Dali::Toolkit::Button::Property *result = 0 ;
64055
64056   {
64057     try {
64058       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
64059     } catch (std::out_of_range& e) {
64060       {
64061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64062       };
64063     } catch (std::exception& e) {
64064       {
64065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64066       };
64067     } catch (...) {
64068       {
64069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64070       };
64071     }
64072   }
64073   jresult = (void *)result;
64074   return jresult;
64075 }
64076
64077
64078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
64079   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
64080
64081   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
64082   {
64083     try {
64084       delete arg1;
64085     } catch (std::out_of_range& e) {
64086       {
64087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64088       };
64089     } catch (std::exception& e) {
64090       {
64091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64092       };
64093     } catch (...) {
64094       {
64095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64096       };
64097     }
64098   }
64099 }
64100
64101
64102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
64103   void * jresult ;
64104   Dali::Toolkit::Button *result = 0 ;
64105
64106   {
64107     try {
64108       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
64109     } catch (std::out_of_range& e) {
64110       {
64111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64112       };
64113     } catch (std::exception& e) {
64114       {
64115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64116       };
64117     } catch (...) {
64118       {
64119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64120       };
64121     }
64122   }
64123   jresult = (void *)result;
64124   return jresult;
64125 }
64126
64127
64128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
64129   void * jresult ;
64130   Dali::Toolkit::Button *arg1 = 0 ;
64131   Dali::Toolkit::Button *result = 0 ;
64132
64133   arg1 = (Dali::Toolkit::Button *)jarg1;
64134   if (!arg1) {
64135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64136     return 0;
64137   }
64138   {
64139     try {
64140       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
64141     } catch (std::out_of_range& e) {
64142       {
64143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64144       };
64145     } catch (std::exception& e) {
64146       {
64147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64148       };
64149     } catch (...) {
64150       {
64151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64152       };
64153     }
64154   }
64155   jresult = (void *)result;
64156   return jresult;
64157 }
64158
64159
64160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
64161   void * jresult ;
64162   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64163   Dali::Toolkit::Button *arg2 = 0 ;
64164   Dali::Toolkit::Button *result = 0 ;
64165
64166   arg1 = (Dali::Toolkit::Button *)jarg1;
64167   arg2 = (Dali::Toolkit::Button *)jarg2;
64168   if (!arg2) {
64169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64170     return 0;
64171   }
64172   {
64173     try {
64174       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
64175     } catch (std::out_of_range& e) {
64176       {
64177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64178       };
64179     } catch (std::exception& e) {
64180       {
64181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64182       };
64183     } catch (...) {
64184       {
64185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64186       };
64187     }
64188   }
64189   jresult = (void *)result;
64190   return jresult;
64191 }
64192
64193
64194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
64195   void * jresult ;
64196   Dali::BaseHandle arg1 ;
64197   Dali::BaseHandle *argp1 ;
64198   Dali::Toolkit::Button result;
64199
64200   argp1 = (Dali::BaseHandle *)jarg1;
64201   if (!argp1) {
64202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64203     return 0;
64204   }
64205   arg1 = *argp1;
64206   {
64207     try {
64208       result = Dali::Toolkit::Button::DownCast(arg1);
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 = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
64224   return jresult;
64225 }
64226
64227
64228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
64229   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64230
64231   arg1 = (Dali::Toolkit::Button *)jarg1;
64232   {
64233     try {
64234       delete arg1;
64235     } catch (std::out_of_range& e) {
64236       {
64237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64238       };
64239     } catch (std::exception& e) {
64240       {
64241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64242       };
64243     } catch (...) {
64244       {
64245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64246       };
64247     }
64248   }
64249 }
64250
64251
64252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
64253   unsigned int jresult ;
64254   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64255   bool result;
64256
64257   arg1 = (Dali::Toolkit::Button *)jarg1;
64258   {
64259     try {
64260       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
64261     } catch (std::out_of_range& e) {
64262       {
64263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64264       };
64265     } catch (std::exception& e) {
64266       {
64267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64268       };
64269     } catch (...) {
64270       {
64271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64272       };
64273     }
64274   }
64275   jresult = result;
64276   return jresult;
64277 }
64278
64279
64280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
64281   unsigned int jresult ;
64282   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64283   bool result;
64284
64285   arg1 = (Dali::Toolkit::Button *)jarg1;
64286   {
64287     try {
64288       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
64289     } catch (std::out_of_range& e) {
64290       {
64291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64292       };
64293     } catch (std::exception& e) {
64294       {
64295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64296       };
64297     } catch (...) {
64298       {
64299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64300       };
64301     }
64302   }
64303   jresult = result;
64304   return jresult;
64305 }
64306
64307
64308 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
64309   float jresult ;
64310   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64311   float result;
64312
64313   arg1 = (Dali::Toolkit::Button *)jarg1;
64314   {
64315     try {
64316       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
64317     } catch (std::out_of_range& e) {
64318       {
64319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64320       };
64321     } catch (std::exception& e) {
64322       {
64323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64324       };
64325     } catch (...) {
64326       {
64327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64328       };
64329     }
64330   }
64331   jresult = result;
64332   return jresult;
64333 }
64334
64335
64336 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
64337   float jresult ;
64338   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64339   float result;
64340
64341   arg1 = (Dali::Toolkit::Button *)jarg1;
64342   {
64343     try {
64344       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
64345     } catch (std::out_of_range& e) {
64346       {
64347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64348       };
64349     } catch (std::exception& e) {
64350       {
64351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64352       };
64353     } catch (...) {
64354       {
64355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64356       };
64357     }
64358   }
64359   jresult = result;
64360   return jresult;
64361 }
64362
64363
64364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
64365   unsigned int jresult ;
64366   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64367   bool result;
64368
64369   arg1 = (Dali::Toolkit::Button *)jarg1;
64370   {
64371     try {
64372       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
64373     } catch (std::out_of_range& e) {
64374       {
64375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64376       };
64377     } catch (std::exception& e) {
64378       {
64379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64380       };
64381     } catch (...) {
64382       {
64383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64384       };
64385     }
64386   }
64387   jresult = result;
64388   return jresult;
64389 }
64390
64391
64392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
64393   unsigned int jresult ;
64394   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64395   bool result;
64396
64397   arg1 = (Dali::Toolkit::Button *)jarg1;
64398   {
64399     try {
64400       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
64401     } catch (std::out_of_range& e) {
64402       {
64403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64404       };
64405     } catch (std::exception& e) {
64406       {
64407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64408       };
64409     } catch (...) {
64410       {
64411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64412       };
64413     }
64414   }
64415   jresult = result;
64416   return jresult;
64417 }
64418
64419
64420 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
64421   float jresult ;
64422   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64423   float result;
64424
64425   arg1 = (Dali::Toolkit::Button *)jarg1;
64426   {
64427     try {
64428       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
64429     } catch (std::out_of_range& e) {
64430       {
64431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64432       };
64433     } catch (std::exception& e) {
64434       {
64435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64436       };
64437     } catch (...) {
64438       {
64439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64440       };
64441     }
64442   }
64443   jresult = result;
64444   return jresult;
64445 }
64446
64447
64448 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
64449   char * jresult ;
64450   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64451   std::string result;
64452
64453   arg1 = (Dali::Toolkit::Button *)jarg1;
64454   {
64455     try {
64456       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
64457     } catch (std::out_of_range& e) {
64458       {
64459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64460       };
64461     } catch (std::exception& e) {
64462       {
64463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64464       };
64465     } catch (...) {
64466       {
64467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64468       };
64469     }
64470   }
64471   jresult = SWIG_csharp_string_callback((&result)->c_str());
64472   return jresult;
64473 }
64474
64475
64476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
64477   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64478   Dali::Actor arg2 ;
64479   Dali::Actor *argp2 ;
64480
64481   arg1 = (Dali::Toolkit::Button *)jarg1;
64482   argp2 = (Dali::Actor *)jarg2;
64483   if (!argp2) {
64484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64485     return ;
64486   }
64487   arg2 = *argp2;
64488   {
64489     try {
64490       (arg1)->SetLabel(arg2);
64491     } catch (std::out_of_range& e) {
64492       {
64493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64494       };
64495     } catch (std::exception& e) {
64496       {
64497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64498       };
64499     } catch (...) {
64500       {
64501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64502       };
64503     }
64504   }
64505 }
64506
64507
64508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
64509   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64510   Dali::Image arg2 ;
64511   Dali::Image *argp2 ;
64512
64513   arg1 = (Dali::Toolkit::Button *)jarg1;
64514   argp2 = (Dali::Image *)jarg2;
64515   if (!argp2) {
64516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64517     return ;
64518   }
64519   arg2 = *argp2;
64520   {
64521     try {
64522       (arg1)->SetButtonImage(arg2);
64523     } catch (std::out_of_range& e) {
64524       {
64525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64526       };
64527     } catch (std::exception& e) {
64528       {
64529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64530       };
64531     } catch (...) {
64532       {
64533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64534       };
64535     }
64536   }
64537 }
64538
64539
64540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
64541   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64542   Dali::Image arg2 ;
64543   Dali::Image *argp2 ;
64544
64545   arg1 = (Dali::Toolkit::Button *)jarg1;
64546   argp2 = (Dali::Image *)jarg2;
64547   if (!argp2) {
64548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64549     return ;
64550   }
64551   arg2 = *argp2;
64552   {
64553     try {
64554       (arg1)->SetSelectedImage(arg2);
64555     } catch (std::out_of_range& e) {
64556       {
64557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64558       };
64559     } catch (std::exception& e) {
64560       {
64561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64562       };
64563     } catch (...) {
64564       {
64565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64566       };
64567     }
64568   }
64569 }
64570
64571
64572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
64573   void * jresult ;
64574   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64575   Dali::Actor result;
64576
64577   arg1 = (Dali::Toolkit::Button *)jarg1;
64578   {
64579     try {
64580       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
64581     } catch (std::out_of_range& e) {
64582       {
64583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64584       };
64585     } catch (std::exception& e) {
64586       {
64587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64588       };
64589     } catch (...) {
64590       {
64591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64592       };
64593     }
64594   }
64595   jresult = new Dali::Actor((const Dali::Actor &)result);
64596   return jresult;
64597 }
64598
64599
64600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
64601   void * jresult ;
64602   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64603   Dali::Actor result;
64604
64605   arg1 = (Dali::Toolkit::Button *)jarg1;
64606   {
64607     try {
64608       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
64609     } catch (std::out_of_range& e) {
64610       {
64611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64612       };
64613     } catch (std::exception& e) {
64614       {
64615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64616       };
64617     } catch (...) {
64618       {
64619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64620       };
64621     }
64622   }
64623   jresult = new Dali::Actor((const Dali::Actor &)result);
64624   return jresult;
64625 }
64626
64627
64628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
64629   void * jresult ;
64630   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64631   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64632
64633   arg1 = (Dali::Toolkit::Button *)jarg1;
64634   {
64635     try {
64636       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
64637     } catch (std::out_of_range& e) {
64638       {
64639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64640       };
64641     } catch (std::exception& e) {
64642       {
64643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64644       };
64645     } catch (...) {
64646       {
64647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64648       };
64649     }
64650   }
64651   jresult = (void *)result;
64652   return jresult;
64653 }
64654
64655
64656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
64657   void * jresult ;
64658   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64659   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64660
64661   arg1 = (Dali::Toolkit::Button *)jarg1;
64662   {
64663     try {
64664       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
64665     } catch (std::out_of_range& e) {
64666       {
64667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64668       };
64669     } catch (std::exception& e) {
64670       {
64671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64672       };
64673     } catch (...) {
64674       {
64675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64676       };
64677     }
64678   }
64679   jresult = (void *)result;
64680   return jresult;
64681 }
64682
64683
64684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
64685   void * jresult ;
64686   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64687   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64688
64689   arg1 = (Dali::Toolkit::Button *)jarg1;
64690   {
64691     try {
64692       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
64693     } catch (std::out_of_range& e) {
64694       {
64695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64696       };
64697     } catch (std::exception& e) {
64698       {
64699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64700       };
64701     } catch (...) {
64702       {
64703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64704       };
64705     }
64706   }
64707   jresult = (void *)result;
64708   return jresult;
64709 }
64710
64711
64712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
64713   void * jresult ;
64714   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64715   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64716
64717   arg1 = (Dali::Toolkit::Button *)jarg1;
64718   {
64719     try {
64720       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
64721     } catch (std::out_of_range& e) {
64722       {
64723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64724       };
64725     } catch (std::exception& e) {
64726       {
64727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64728       };
64729     } catch (...) {
64730       {
64731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64732       };
64733     }
64734   }
64735   jresult = (void *)result;
64736   return jresult;
64737 }
64738
64739
64740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
64741   void * jresult ;
64742   Dali::Toolkit::CheckBoxButton *result = 0 ;
64743
64744   {
64745     try {
64746       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
64747     } catch (std::out_of_range& e) {
64748       {
64749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64750       };
64751     } catch (std::exception& e) {
64752       {
64753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64754       };
64755     } catch (...) {
64756       {
64757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64758       };
64759     }
64760   }
64761   jresult = (void *)result;
64762   return jresult;
64763 }
64764
64765
64766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
64767   void * jresult ;
64768   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
64769   Dali::Toolkit::CheckBoxButton *result = 0 ;
64770
64771   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64772   if (!arg1) {
64773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
64774     return 0;
64775   }
64776   {
64777     try {
64778       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
64779     } catch (std::out_of_range& e) {
64780       {
64781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64782       };
64783     } catch (std::exception& e) {
64784       {
64785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64786       };
64787     } catch (...) {
64788       {
64789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64790       };
64791     }
64792   }
64793   jresult = (void *)result;
64794   return jresult;
64795 }
64796
64797
64798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
64799   void * jresult ;
64800   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
64801   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
64802   Dali::Toolkit::CheckBoxButton *result = 0 ;
64803
64804   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64805   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
64806   if (!arg2) {
64807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
64808     return 0;
64809   }
64810   {
64811     try {
64812       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
64813     } catch (std::out_of_range& e) {
64814       {
64815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64816       };
64817     } catch (std::exception& e) {
64818       {
64819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64820       };
64821     } catch (...) {
64822       {
64823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64824       };
64825     }
64826   }
64827   jresult = (void *)result;
64828   return jresult;
64829 }
64830
64831
64832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
64833   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
64834
64835   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64836   {
64837     try {
64838       delete arg1;
64839     } catch (std::out_of_range& e) {
64840       {
64841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64842       };
64843     } catch (std::exception& e) {
64844       {
64845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64846       };
64847     } catch (...) {
64848       {
64849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64850       };
64851     }
64852   }
64853 }
64854
64855
64856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
64857   void * jresult ;
64858   Dali::Toolkit::CheckBoxButton result;
64859
64860   {
64861     try {
64862       result = Dali::Toolkit::CheckBoxButton::New();
64863     } catch (std::out_of_range& e) {
64864       {
64865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64866       };
64867     } catch (std::exception& e) {
64868       {
64869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64870       };
64871     } catch (...) {
64872       {
64873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64874       };
64875     }
64876   }
64877   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
64878   return jresult;
64879 }
64880
64881
64882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
64883   void * jresult ;
64884   Dali::BaseHandle arg1 ;
64885   Dali::BaseHandle *argp1 ;
64886   Dali::Toolkit::CheckBoxButton result;
64887
64888   argp1 = (Dali::BaseHandle *)jarg1;
64889   if (!argp1) {
64890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64891     return 0;
64892   }
64893   arg1 = *argp1;
64894   {
64895     try {
64896       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
64897     } catch (std::out_of_range& e) {
64898       {
64899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64900       };
64901     } catch (std::exception& e) {
64902       {
64903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64904       };
64905     } catch (...) {
64906       {
64907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64908       };
64909     }
64910   }
64911   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
64912   return jresult;
64913 }
64914
64915
64916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
64917   int jresult ;
64918   int result;
64919
64920   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
64921   jresult = (int)result;
64922   return jresult;
64923 }
64924
64925
64926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
64927   int jresult ;
64928   int result;
64929
64930   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
64931   jresult = (int)result;
64932   return jresult;
64933 }
64934
64935
64936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
64937   int jresult ;
64938   int result;
64939
64940   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
64941   jresult = (int)result;
64942   return jresult;
64943 }
64944
64945
64946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
64947   int jresult ;
64948   int result;
64949
64950   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
64951   jresult = (int)result;
64952   return jresult;
64953 }
64954
64955
64956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
64957   int jresult ;
64958   int result;
64959
64960   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
64961   jresult = (int)result;
64962   return jresult;
64963 }
64964
64965
64966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
64967   void * jresult ;
64968   Dali::Toolkit::PushButton::Property *result = 0 ;
64969
64970   {
64971     try {
64972       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
64973     } catch (std::out_of_range& e) {
64974       {
64975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64976       };
64977     } catch (std::exception& e) {
64978       {
64979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64980       };
64981     } catch (...) {
64982       {
64983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64984       };
64985     }
64986   }
64987   jresult = (void *)result;
64988   return jresult;
64989 }
64990
64991
64992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
64993   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
64994
64995   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
64996   {
64997     try {
64998       delete arg1;
64999     } catch (std::out_of_range& e) {
65000       {
65001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65002       };
65003     } catch (std::exception& e) {
65004       {
65005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65006       };
65007     } catch (...) {
65008       {
65009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65010       };
65011     }
65012   }
65013 }
65014
65015
65016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
65017   void * jresult ;
65018   Dali::Toolkit::PushButton *result = 0 ;
65019
65020   {
65021     try {
65022       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65023     } catch (std::out_of_range& e) {
65024       {
65025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65026       };
65027     } catch (std::exception& e) {
65028       {
65029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65030       };
65031     } catch (...) {
65032       {
65033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65034       };
65035     }
65036   }
65037   jresult = (void *)result;
65038   return jresult;
65039 }
65040
65041
65042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
65043   void * jresult ;
65044   Dali::Toolkit::PushButton *arg1 = 0 ;
65045   Dali::Toolkit::PushButton *result = 0 ;
65046
65047   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65048   if (!arg1) {
65049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65050     return 0;
65051   }
65052   {
65053     try {
65054       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65055     } catch (std::out_of_range& e) {
65056       {
65057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65058       };
65059     } catch (std::exception& e) {
65060       {
65061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65062       };
65063     } catch (...) {
65064       {
65065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65066       };
65067     }
65068   }
65069   jresult = (void *)result;
65070   return jresult;
65071 }
65072
65073
65074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
65075   void * jresult ;
65076   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65077   Dali::Toolkit::PushButton *arg2 = 0 ;
65078   Dali::Toolkit::PushButton *result = 0 ;
65079
65080   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65081   arg2 = (Dali::Toolkit::PushButton *)jarg2;
65082   if (!arg2) {
65083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65084     return 0;
65085   }
65086   {
65087     try {
65088       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
65089     } catch (std::out_of_range& e) {
65090       {
65091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65092       };
65093     } catch (std::exception& e) {
65094       {
65095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65096       };
65097     } catch (...) {
65098       {
65099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65100       };
65101     }
65102   }
65103   jresult = (void *)result;
65104   return jresult;
65105 }
65106
65107
65108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
65109   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65110
65111   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65112   {
65113     try {
65114       delete arg1;
65115     } catch (std::out_of_range& e) {
65116       {
65117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65118       };
65119     } catch (std::exception& e) {
65120       {
65121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65122       };
65123     } catch (...) {
65124       {
65125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65126       };
65127     }
65128   }
65129 }
65130
65131
65132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
65133   void * jresult ;
65134   Dali::Toolkit::PushButton result;
65135
65136   {
65137     try {
65138       result = Dali::Toolkit::PushButton::New();
65139     } catch (std::out_of_range& e) {
65140       {
65141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65142       };
65143     } catch (std::exception& e) {
65144       {
65145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65146       };
65147     } catch (...) {
65148       {
65149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65150       };
65151     }
65152   }
65153   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65154   return jresult;
65155 }
65156
65157
65158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
65159   void * jresult ;
65160   Dali::BaseHandle arg1 ;
65161   Dali::BaseHandle *argp1 ;
65162   Dali::Toolkit::PushButton result;
65163
65164   argp1 = (Dali::BaseHandle *)jarg1;
65165   if (!argp1) {
65166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65167     return 0;
65168   }
65169   arg1 = *argp1;
65170   {
65171     try {
65172       result = Dali::Toolkit::PushButton::DownCast(arg1);
65173     } catch (std::out_of_range& e) {
65174       {
65175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65176       };
65177     } catch (std::exception& e) {
65178       {
65179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65180       };
65181     } catch (...) {
65182       {
65183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65184       };
65185     }
65186   }
65187   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65188   return jresult;
65189 }
65190
65191
65192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
65193   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65194   Dali::Image arg2 ;
65195   Dali::Image *argp2 ;
65196
65197   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65198   argp2 = (Dali::Image *)jarg2;
65199   if (!argp2) {
65200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65201     return ;
65202   }
65203   arg2 = *argp2;
65204   {
65205     try {
65206       (arg1)->SetButtonImage(arg2);
65207     } catch (std::out_of_range& e) {
65208       {
65209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65210       };
65211     } catch (std::exception& e) {
65212       {
65213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65214       };
65215     } catch (...) {
65216       {
65217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65218       };
65219     }
65220   }
65221 }
65222
65223
65224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
65225   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65226   Dali::Actor arg2 ;
65227   Dali::Actor *argp2 ;
65228
65229   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65230   argp2 = (Dali::Actor *)jarg2;
65231   if (!argp2) {
65232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65233     return ;
65234   }
65235   arg2 = *argp2;
65236   {
65237     try {
65238       (arg1)->SetButtonImage(arg2);
65239     } catch (std::out_of_range& e) {
65240       {
65241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65242       };
65243     } catch (std::exception& e) {
65244       {
65245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65246       };
65247     } catch (...) {
65248       {
65249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65250       };
65251     }
65252   }
65253 }
65254
65255
65256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
65257   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65258   Dali::Actor arg2 ;
65259   Dali::Actor *argp2 ;
65260
65261   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65262   argp2 = (Dali::Actor *)jarg2;
65263   if (!argp2) {
65264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65265     return ;
65266   }
65267   arg2 = *argp2;
65268   {
65269     try {
65270       (arg1)->SetBackgroundImage(arg2);
65271     } catch (std::out_of_range& e) {
65272       {
65273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65274       };
65275     } catch (std::exception& e) {
65276       {
65277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65278       };
65279     } catch (...) {
65280       {
65281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65282       };
65283     }
65284   }
65285 }
65286
65287
65288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
65289   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65290   Dali::Image arg2 ;
65291   Dali::Image *argp2 ;
65292
65293   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65294   argp2 = (Dali::Image *)jarg2;
65295   if (!argp2) {
65296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65297     return ;
65298   }
65299   arg2 = *argp2;
65300   {
65301     try {
65302       (arg1)->SetSelectedImage(arg2);
65303     } catch (std::out_of_range& e) {
65304       {
65305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65306       };
65307     } catch (std::exception& e) {
65308       {
65309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65310       };
65311     } catch (...) {
65312       {
65313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65314       };
65315     }
65316   }
65317 }
65318
65319
65320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
65321   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65322   Dali::Actor arg2 ;
65323   Dali::Actor *argp2 ;
65324
65325   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65326   argp2 = (Dali::Actor *)jarg2;
65327   if (!argp2) {
65328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65329     return ;
65330   }
65331   arg2 = *argp2;
65332   {
65333     try {
65334       (arg1)->SetSelectedImage(arg2);
65335     } catch (std::out_of_range& e) {
65336       {
65337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65338       };
65339     } catch (std::exception& e) {
65340       {
65341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65342       };
65343     } catch (...) {
65344       {
65345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65346       };
65347     }
65348   }
65349 }
65350
65351
65352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
65353   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65354   Dali::Actor arg2 ;
65355   Dali::Actor *argp2 ;
65356
65357   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65358   argp2 = (Dali::Actor *)jarg2;
65359   if (!argp2) {
65360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65361     return ;
65362   }
65363   arg2 = *argp2;
65364   {
65365     try {
65366       (arg1)->SetSelectedBackgroundImage(arg2);
65367     } catch (std::out_of_range& e) {
65368       {
65369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65370       };
65371     } catch (std::exception& e) {
65372       {
65373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65374       };
65375     } catch (...) {
65376       {
65377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65378       };
65379     }
65380   }
65381 }
65382
65383
65384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
65385   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65386   Dali::Actor arg2 ;
65387   Dali::Actor *argp2 ;
65388
65389   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65390   argp2 = (Dali::Actor *)jarg2;
65391   if (!argp2) {
65392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65393     return ;
65394   }
65395   arg2 = *argp2;
65396   {
65397     try {
65398       (arg1)->SetDisabledBackgroundImage(arg2);
65399     } catch (std::out_of_range& e) {
65400       {
65401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65402       };
65403     } catch (std::exception& e) {
65404       {
65405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65406       };
65407     } catch (...) {
65408       {
65409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65410       };
65411     }
65412   }
65413 }
65414
65415
65416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
65417   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65418   Dali::Actor arg2 ;
65419   Dali::Actor *argp2 ;
65420
65421   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65422   argp2 = (Dali::Actor *)jarg2;
65423   if (!argp2) {
65424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65425     return ;
65426   }
65427   arg2 = *argp2;
65428   {
65429     try {
65430       (arg1)->SetDisabledImage(arg2);
65431     } catch (std::out_of_range& e) {
65432       {
65433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65434       };
65435     } catch (std::exception& e) {
65436       {
65437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65438       };
65439     } catch (...) {
65440       {
65441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65442       };
65443     }
65444   }
65445 }
65446
65447
65448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
65449   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65450   Dali::Actor arg2 ;
65451   Dali::Actor *argp2 ;
65452
65453   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65454   argp2 = (Dali::Actor *)jarg2;
65455   if (!argp2) {
65456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65457     return ;
65458   }
65459   arg2 = *argp2;
65460   {
65461     try {
65462       (arg1)->SetDisabledSelectedImage(arg2);
65463     } catch (std::out_of_range& e) {
65464       {
65465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65466       };
65467     } catch (std::exception& e) {
65468       {
65469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65470       };
65471     } catch (...) {
65472       {
65473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65474       };
65475     }
65476   }
65477 }
65478
65479
65480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
65481   void * jresult ;
65482   Dali::Toolkit::RadioButton *result = 0 ;
65483
65484   {
65485     try {
65486       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
65487     } catch (std::out_of_range& e) {
65488       {
65489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65490       };
65491     } catch (std::exception& e) {
65492       {
65493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65494       };
65495     } catch (...) {
65496       {
65497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65498       };
65499     }
65500   }
65501   jresult = (void *)result;
65502   return jresult;
65503 }
65504
65505
65506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65507   void * jresult ;
65508   Dali::Toolkit::RadioButton *arg1 = 0 ;
65509   Dali::Toolkit::RadioButton *result = 0 ;
65510
65511   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65512   if (!arg1) {
65513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65514     return 0;
65515   }
65516   {
65517     try {
65518       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65519     } catch (std::out_of_range& e) {
65520       {
65521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65522       };
65523     } catch (std::exception& e) {
65524       {
65525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65526       };
65527     } catch (...) {
65528       {
65529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65530       };
65531     }
65532   }
65533   jresult = (void *)result;
65534   return jresult;
65535 }
65536
65537
65538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65539   void * jresult ;
65540   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65541   Dali::Toolkit::RadioButton *arg2 = 0 ;
65542   Dali::Toolkit::RadioButton *result = 0 ;
65543
65544   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65545   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65546   if (!arg2) {
65547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65548     return 0;
65549   }
65550   {
65551     try {
65552       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65553     } catch (std::out_of_range& e) {
65554       {
65555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65556       };
65557     } catch (std::exception& e) {
65558       {
65559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65560       };
65561     } catch (...) {
65562       {
65563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65564       };
65565     }
65566   }
65567   jresult = (void *)result;
65568   return jresult;
65569 }
65570
65571
65572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
65573   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65574
65575   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65576   {
65577     try {
65578       delete arg1;
65579     } catch (std::out_of_range& e) {
65580       {
65581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65582       };
65583     } catch (std::exception& e) {
65584       {
65585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65586       };
65587     } catch (...) {
65588       {
65589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65590       };
65591     }
65592   }
65593 }
65594
65595
65596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
65597   void * jresult ;
65598   Dali::Toolkit::RadioButton result;
65599
65600   {
65601     try {
65602       result = Dali::Toolkit::RadioButton::New();
65603     } catch (std::out_of_range& e) {
65604       {
65605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65606       };
65607     } catch (std::exception& e) {
65608       {
65609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65610       };
65611     } catch (...) {
65612       {
65613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65614       };
65615     }
65616   }
65617   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65618   return jresult;
65619 }
65620
65621
65622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
65623   void * jresult ;
65624   std::string *arg1 = 0 ;
65625   Dali::Toolkit::RadioButton result;
65626
65627   if (!jarg1) {
65628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65629     return 0;
65630   }
65631   std::string arg1_str(jarg1);
65632   arg1 = &arg1_str;
65633   {
65634     try {
65635       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
65636     } catch (std::out_of_range& e) {
65637       {
65638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65639       };
65640     } catch (std::exception& e) {
65641       {
65642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65643       };
65644     } catch (...) {
65645       {
65646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65647       };
65648     }
65649   }
65650   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65651
65652   //argout typemap for const std::string&
65653
65654   return jresult;
65655 }
65656
65657
65658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
65659   void * jresult ;
65660   Dali::BaseHandle arg1 ;
65661   Dali::BaseHandle *argp1 ;
65662   Dali::Toolkit::RadioButton result;
65663
65664   argp1 = (Dali::BaseHandle *)jarg1;
65665   if (!argp1) {
65666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65667     return 0;
65668   }
65669   arg1 = *argp1;
65670   {
65671     try {
65672       result = Dali::Toolkit::RadioButton::DownCast(arg1);
65673     } catch (std::out_of_range& e) {
65674       {
65675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65676       };
65677     } catch (std::exception& e) {
65678       {
65679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65680       };
65681     } catch (...) {
65682       {
65683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65684       };
65685     }
65686   }
65687   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65688   return jresult;
65689 }
65690
65691
65692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
65693   int jresult ;
65694   int result;
65695
65696   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
65697   jresult = (int)result;
65698   return jresult;
65699 }
65700
65701
65702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
65703   int jresult ;
65704   int result;
65705
65706   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
65707   jresult = (int)result;
65708   return jresult;
65709 }
65710
65711
65712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
65713   int jresult ;
65714   int result;
65715
65716   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
65717   jresult = (int)result;
65718   return jresult;
65719 }
65720
65721
65722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
65723   int jresult ;
65724   int result;
65725
65726   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
65727   jresult = (int)result;
65728   return jresult;
65729 }
65730
65731
65732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
65733   int jresult ;
65734   int result;
65735
65736   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
65737   jresult = (int)result;
65738   return jresult;
65739 }
65740
65741
65742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
65743   int jresult ;
65744   int result;
65745
65746   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
65747   jresult = (int)result;
65748   return jresult;
65749 }
65750
65751
65752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
65753   void * jresult ;
65754   Dali::Toolkit::FlexContainer::Property *result = 0 ;
65755
65756   {
65757     try {
65758       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
65759     } catch (std::out_of_range& e) {
65760       {
65761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65762       };
65763     } catch (std::exception& e) {
65764       {
65765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65766       };
65767     } catch (...) {
65768       {
65769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65770       };
65771     }
65772   }
65773   jresult = (void *)result;
65774   return jresult;
65775 }
65776
65777
65778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
65779   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
65780
65781   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
65782   {
65783     try {
65784       delete arg1;
65785     } catch (std::out_of_range& e) {
65786       {
65787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65788       };
65789     } catch (std::exception& e) {
65790       {
65791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65792       };
65793     } catch (...) {
65794       {
65795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65796       };
65797     }
65798   }
65799 }
65800
65801
65802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
65803   int jresult ;
65804   int result;
65805
65806   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
65807   jresult = (int)result;
65808   return jresult;
65809 }
65810
65811
65812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
65813   int jresult ;
65814   int result;
65815
65816   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
65817   jresult = (int)result;
65818   return jresult;
65819 }
65820
65821
65822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
65823   int jresult ;
65824   int result;
65825
65826   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
65827   jresult = (int)result;
65828   return jresult;
65829 }
65830
65831
65832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
65833   void * jresult ;
65834   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
65835
65836   {
65837     try {
65838       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
65839     } catch (std::out_of_range& e) {
65840       {
65841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65842       };
65843     } catch (std::exception& e) {
65844       {
65845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65846       };
65847     } catch (...) {
65848       {
65849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65850       };
65851     }
65852   }
65853   jresult = (void *)result;
65854   return jresult;
65855 }
65856
65857
65858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
65859   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
65860
65861   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
65862   {
65863     try {
65864       delete arg1;
65865     } catch (std::out_of_range& e) {
65866       {
65867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65868       };
65869     } catch (std::exception& e) {
65870       {
65871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65872       };
65873     } catch (...) {
65874       {
65875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65876       };
65877     }
65878   }
65879 }
65880
65881
65882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
65883   void * jresult ;
65884   Dali::Toolkit::FlexContainer *result = 0 ;
65885
65886   {
65887     try {
65888       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
65889     } catch (std::out_of_range& e) {
65890       {
65891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65892       };
65893     } catch (std::exception& e) {
65894       {
65895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65896       };
65897     } catch (...) {
65898       {
65899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65900       };
65901     }
65902   }
65903   jresult = (void *)result;
65904   return jresult;
65905 }
65906
65907
65908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
65909   void * jresult ;
65910   Dali::Toolkit::FlexContainer *arg1 = 0 ;
65911   Dali::Toolkit::FlexContainer *result = 0 ;
65912
65913   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65914   if (!arg1) {
65915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
65916     return 0;
65917   }
65918   {
65919     try {
65920       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
65921     } catch (std::out_of_range& e) {
65922       {
65923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65924       };
65925     } catch (std::exception& e) {
65926       {
65927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65928       };
65929     } catch (...) {
65930       {
65931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65932       };
65933     }
65934   }
65935   jresult = (void *)result;
65936   return jresult;
65937 }
65938
65939
65940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
65941   void * jresult ;
65942   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
65943   Dali::Toolkit::FlexContainer *arg2 = 0 ;
65944   Dali::Toolkit::FlexContainer *result = 0 ;
65945
65946   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65947   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
65948   if (!arg2) {
65949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
65950     return 0;
65951   }
65952   {
65953     try {
65954       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
65955     } catch (std::out_of_range& e) {
65956       {
65957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65958       };
65959     } catch (std::exception& e) {
65960       {
65961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65962       };
65963     } catch (...) {
65964       {
65965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65966       };
65967     }
65968   }
65969   jresult = (void *)result;
65970   return jresult;
65971 }
65972
65973
65974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
65975   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
65976
65977   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65978   {
65979     try {
65980       delete arg1;
65981     } catch (std::out_of_range& e) {
65982       {
65983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65984       };
65985     } catch (std::exception& e) {
65986       {
65987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65988       };
65989     } catch (...) {
65990       {
65991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65992       };
65993     }
65994   }
65995 }
65996
65997
65998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
65999   void * jresult ;
66000   Dali::Toolkit::FlexContainer result;
66001
66002   {
66003     try {
66004       result = Dali::Toolkit::FlexContainer::New();
66005     } catch (std::out_of_range& e) {
66006       {
66007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66008       };
66009     } catch (std::exception& e) {
66010       {
66011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66012       };
66013     } catch (...) {
66014       {
66015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66016       };
66017     }
66018   }
66019   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66020   return jresult;
66021 }
66022
66023
66024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
66025   void * jresult ;
66026   Dali::BaseHandle arg1 ;
66027   Dali::BaseHandle *argp1 ;
66028   Dali::Toolkit::FlexContainer result;
66029
66030   argp1 = (Dali::BaseHandle *)jarg1;
66031   if (!argp1) {
66032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66033     return 0;
66034   }
66035   arg1 = *argp1;
66036   {
66037     try {
66038       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66039     } catch (std::out_of_range& e) {
66040       {
66041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66042       };
66043     } catch (std::exception& e) {
66044       {
66045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66046       };
66047     } catch (...) {
66048       {
66049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66050       };
66051     }
66052   }
66053   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66054   return jresult;
66055 }
66056
66057
66058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
66059   int jresult ;
66060   int result;
66061
66062   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
66063   jresult = (int)result;
66064   return jresult;
66065 }
66066
66067
66068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
66069   int jresult ;
66070   int result;
66071
66072   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
66073   jresult = (int)result;
66074   return jresult;
66075 }
66076
66077
66078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
66079   int jresult ;
66080   int result;
66081
66082   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
66083   jresult = (int)result;
66084   return jresult;
66085 }
66086
66087
66088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
66089   int jresult ;
66090   int result;
66091
66092   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
66093   jresult = (int)result;
66094   return jresult;
66095 }
66096
66097
66098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
66099   void * jresult ;
66100   Dali::Toolkit::ImageView::Property *result = 0 ;
66101
66102   {
66103     try {
66104       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
66105     } catch (std::out_of_range& e) {
66106       {
66107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66108       };
66109     } catch (std::exception& e) {
66110       {
66111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66112       };
66113     } catch (...) {
66114       {
66115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66116       };
66117     }
66118   }
66119   jresult = (void *)result;
66120   return jresult;
66121 }
66122
66123
66124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
66125   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
66126
66127   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
66128   {
66129     try {
66130       delete arg1;
66131     } catch (std::out_of_range& e) {
66132       {
66133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66134       };
66135     } catch (std::exception& e) {
66136       {
66137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66138       };
66139     } catch (...) {
66140       {
66141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66142       };
66143     }
66144   }
66145 }
66146
66147
66148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66149   void * jresult ;
66150   Dali::Toolkit::ImageView *result = 0 ;
66151
66152   {
66153     try {
66154       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66155     } catch (std::out_of_range& e) {
66156       {
66157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66158       };
66159     } catch (std::exception& e) {
66160       {
66161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66162       };
66163     } catch (...) {
66164       {
66165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66166       };
66167     }
66168   }
66169   jresult = (void *)result;
66170   return jresult;
66171 }
66172
66173
66174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66175   void * jresult ;
66176   Dali::Toolkit::ImageView result;
66177
66178   {
66179     try {
66180       result = Dali::Toolkit::ImageView::New();
66181     } catch (std::out_of_range& e) {
66182       {
66183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66184       };
66185     } catch (std::exception& e) {
66186       {
66187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66188       };
66189     } catch (...) {
66190       {
66191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66192       };
66193     }
66194   }
66195   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66196   return jresult;
66197 }
66198
66199
66200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
66201   void * jresult ;
66202   Dali::Image arg1 ;
66203   Dali::Image *argp1 ;
66204   Dali::Toolkit::ImageView result;
66205
66206   argp1 = (Dali::Image *)jarg1;
66207   if (!argp1) {
66208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66209     return 0;
66210   }
66211   arg1 = *argp1;
66212   {
66213     try {
66214       result = Dali::Toolkit::ImageView::New(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 = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66230   return jresult;
66231 }
66232
66233
66234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
66235   void * jresult ;
66236   std::string *arg1 = 0 ;
66237   Dali::Toolkit::ImageView result;
66238
66239   if (!jarg1) {
66240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66241     return 0;
66242   }
66243   std::string arg1_str(jarg1);
66244   arg1 = &arg1_str;
66245   {
66246     try {
66247       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66248     } catch (std::out_of_range& e) {
66249       {
66250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66251       };
66252     } catch (std::exception& e) {
66253       {
66254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66255       };
66256     } catch (...) {
66257       {
66258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66259       };
66260     }
66261   }
66262   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66263
66264   //argout typemap for const std::string&
66265
66266   return jresult;
66267 }
66268
66269
66270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66271   void * jresult ;
66272   std::string *arg1 = 0 ;
66273   Dali::ImageDimensions arg2 ;
66274   Dali::ImageDimensions *argp2 ;
66275   Dali::Toolkit::ImageView result;
66276
66277   if (!jarg1) {
66278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66279     return 0;
66280   }
66281   std::string arg1_str(jarg1);
66282   arg1 = &arg1_str;
66283   argp2 = (Dali::ImageDimensions *)jarg2;
66284   if (!argp2) {
66285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66286     return 0;
66287   }
66288   arg2 = *argp2;
66289   {
66290     try {
66291       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66292     } catch (std::out_of_range& e) {
66293       {
66294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66295       };
66296     } catch (std::exception& e) {
66297       {
66298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66299       };
66300     } catch (...) {
66301       {
66302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66303       };
66304     }
66305   }
66306   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66307
66308   //argout typemap for const std::string&
66309
66310   return jresult;
66311 }
66312
66313
66314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66315   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66316
66317   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66318   {
66319     try {
66320       delete arg1;
66321     } catch (std::out_of_range& e) {
66322       {
66323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66324       };
66325     } catch (std::exception& e) {
66326       {
66327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66328       };
66329     } catch (...) {
66330       {
66331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66332       };
66333     }
66334   }
66335 }
66336
66337
66338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66339   void * jresult ;
66340   Dali::Toolkit::ImageView *arg1 = 0 ;
66341   Dali::Toolkit::ImageView *result = 0 ;
66342
66343   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66344   if (!arg1) {
66345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66346     return 0;
66347   }
66348   {
66349     try {
66350       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66351     } catch (std::out_of_range& e) {
66352       {
66353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66354       };
66355     } catch (std::exception& e) {
66356       {
66357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66358       };
66359     } catch (...) {
66360       {
66361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66362       };
66363     }
66364   }
66365   jresult = (void *)result;
66366   return jresult;
66367 }
66368
66369
66370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66371   void * jresult ;
66372   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66373   Dali::Toolkit::ImageView *arg2 = 0 ;
66374   Dali::Toolkit::ImageView *result = 0 ;
66375
66376   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66377   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66378   if (!arg2) {
66379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66380     return 0;
66381   }
66382   {
66383     try {
66384       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66385     } catch (std::out_of_range& e) {
66386       {
66387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66388       };
66389     } catch (std::exception& e) {
66390       {
66391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66392       };
66393     } catch (...) {
66394       {
66395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66396       };
66397     }
66398   }
66399   jresult = (void *)result;
66400   return jresult;
66401 }
66402
66403
66404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
66405   void * jresult ;
66406   Dali::BaseHandle arg1 ;
66407   Dali::BaseHandle *argp1 ;
66408   Dali::Toolkit::ImageView result;
66409
66410   argp1 = (Dali::BaseHandle *)jarg1;
66411   if (!argp1) {
66412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66413     return 0;
66414   }
66415   arg1 = *argp1;
66416   {
66417     try {
66418       result = Dali::Toolkit::ImageView::DownCast(arg1);
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::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66434   return jresult;
66435 }
66436
66437
66438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
66439   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66440   Dali::Image arg2 ;
66441   Dali::Image *argp2 ;
66442
66443   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66444   argp2 = (Dali::Image *)jarg2;
66445   if (!argp2) {
66446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66447     return ;
66448   }
66449   arg2 = *argp2;
66450   {
66451     try {
66452       (arg1)->SetImage(arg2);
66453     } catch (std::out_of_range& e) {
66454       {
66455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66456       };
66457     } catch (std::exception& e) {
66458       {
66459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66460       };
66461     } catch (...) {
66462       {
66463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66464       };
66465     }
66466   }
66467 }
66468
66469
66470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
66471   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66472   std::string *arg2 = 0 ;
66473
66474   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66475   if (!jarg2) {
66476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66477     return ;
66478   }
66479   std::string arg2_str(jarg2);
66480   arg2 = &arg2_str;
66481   {
66482     try {
66483       (arg1)->SetImage((std::string const &)*arg2);
66484     } catch (std::out_of_range& e) {
66485       {
66486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66487       };
66488     } catch (std::exception& e) {
66489       {
66490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66491       };
66492     } catch (...) {
66493       {
66494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66495       };
66496     }
66497   }
66498
66499   //argout typemap for const std::string&
66500
66501 }
66502
66503
66504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66505   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66506   std::string *arg2 = 0 ;
66507   Dali::ImageDimensions arg3 ;
66508   Dali::ImageDimensions *argp3 ;
66509
66510   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66511   if (!jarg2) {
66512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66513     return ;
66514   }
66515   std::string arg2_str(jarg2);
66516   arg2 = &arg2_str;
66517   argp3 = (Dali::ImageDimensions *)jarg3;
66518   if (!argp3) {
66519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66520     return ;
66521   }
66522   arg3 = *argp3;
66523   {
66524     try {
66525       (arg1)->SetImage((std::string const &)*arg2,arg3);
66526     } catch (std::out_of_range& e) {
66527       {
66528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66529       };
66530     } catch (std::exception& e) {
66531       {
66532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66533       };
66534     } catch (...) {
66535       {
66536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66537       };
66538     }
66539   }
66540
66541   //argout typemap for const std::string&
66542
66543 }
66544
66545
66546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
66547   void * jresult ;
66548   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66549   Dali::Image result;
66550
66551   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66552   {
66553     try {
66554       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
66555     } catch (std::out_of_range& e) {
66556       {
66557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66558       };
66559     } catch (std::exception& e) {
66560       {
66561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66562       };
66563     } catch (...) {
66564       {
66565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66566       };
66567     }
66568   }
66569   jresult = new Dali::Image((const Dali::Image &)result);
66570   return jresult;
66571 }
66572
66573
66574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
66575   int jresult ;
66576   int result;
66577
66578   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
66579   jresult = (int)result;
66580   return jresult;
66581 }
66582
66583
66584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
66585   int jresult ;
66586   int result;
66587
66588   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
66589   jresult = (int)result;
66590   return jresult;
66591 }
66592
66593
66594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
66595   int jresult ;
66596   int result;
66597
66598   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
66599   jresult = (int)result;
66600   return jresult;
66601 }
66602
66603
66604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
66605   int jresult ;
66606   int result;
66607
66608   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
66609   jresult = (int)result;
66610   return jresult;
66611 }
66612
66613
66614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
66615   int jresult ;
66616   int result;
66617
66618   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
66619   jresult = (int)result;
66620   return jresult;
66621 }
66622
66623
66624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
66625   int jresult ;
66626   int result;
66627
66628   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
66629   jresult = (int)result;
66630   return jresult;
66631 }
66632
66633
66634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
66635   int jresult ;
66636   int result;
66637
66638   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
66639   jresult = (int)result;
66640   return jresult;
66641 }
66642
66643
66644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
66645   int jresult ;
66646   int result;
66647
66648   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
66649   jresult = (int)result;
66650   return jresult;
66651 }
66652
66653
66654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
66655   void * jresult ;
66656   Dali::Toolkit::Model3dView::Property *result = 0 ;
66657
66658   {
66659     try {
66660       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
66661     } catch (std::out_of_range& e) {
66662       {
66663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66664       };
66665     } catch (std::exception& e) {
66666       {
66667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66668       };
66669     } catch (...) {
66670       {
66671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66672       };
66673     }
66674   }
66675   jresult = (void *)result;
66676   return jresult;
66677 }
66678
66679
66680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
66681   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
66682
66683   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
66684   {
66685     try {
66686       delete arg1;
66687     } catch (std::out_of_range& e) {
66688       {
66689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66690       };
66691     } catch (std::exception& e) {
66692       {
66693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66694       };
66695     } catch (...) {
66696       {
66697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66698       };
66699     }
66700   }
66701 }
66702
66703
66704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
66705   void * jresult ;
66706   Dali::Toolkit::Model3dView result;
66707
66708   {
66709     try {
66710       result = Dali::Toolkit::Model3dView::New();
66711     } catch (std::out_of_range& e) {
66712       {
66713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66714       };
66715     } catch (std::exception& e) {
66716       {
66717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66718       };
66719     } catch (...) {
66720       {
66721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66722       };
66723     }
66724   }
66725   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66726   return jresult;
66727 }
66728
66729
66730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
66731   void * jresult ;
66732   std::string *arg1 = 0 ;
66733   std::string *arg2 = 0 ;
66734   std::string *arg3 = 0 ;
66735   Dali::Toolkit::Model3dView result;
66736
66737   if (!jarg1) {
66738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66739     return 0;
66740   }
66741   std::string arg1_str(jarg1);
66742   arg1 = &arg1_str;
66743   if (!jarg2) {
66744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66745     return 0;
66746   }
66747   std::string arg2_str(jarg2);
66748   arg2 = &arg2_str;
66749   if (!jarg3) {
66750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66751     return 0;
66752   }
66753   std::string arg3_str(jarg3);
66754   arg3 = &arg3_str;
66755   {
66756     try {
66757       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
66758     } catch (std::out_of_range& e) {
66759       {
66760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66761       };
66762     } catch (std::exception& e) {
66763       {
66764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66765       };
66766     } catch (...) {
66767       {
66768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66769       };
66770     }
66771   }
66772   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66773
66774   //argout typemap for const std::string&
66775
66776
66777   //argout typemap for const std::string&
66778
66779
66780   //argout typemap for const std::string&
66781
66782   return jresult;
66783 }
66784
66785
66786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
66787   void * jresult ;
66788   Dali::Toolkit::Model3dView *result = 0 ;
66789
66790   {
66791     try {
66792       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
66793     } catch (std::out_of_range& e) {
66794       {
66795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66796       };
66797     } catch (std::exception& e) {
66798       {
66799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66800       };
66801     } catch (...) {
66802       {
66803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66804       };
66805     }
66806   }
66807   jresult = (void *)result;
66808   return jresult;
66809 }
66810
66811
66812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
66813   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66814
66815   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66816   {
66817     try {
66818       delete arg1;
66819     } catch (std::out_of_range& e) {
66820       {
66821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66822       };
66823     } catch (std::exception& e) {
66824       {
66825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66826       };
66827     } catch (...) {
66828       {
66829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66830       };
66831     }
66832   }
66833 }
66834
66835
66836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
66837   void * jresult ;
66838   Dali::Toolkit::Model3dView *arg1 = 0 ;
66839   Dali::Toolkit::Model3dView *result = 0 ;
66840
66841   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66842   if (!arg1) {
66843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66844     return 0;
66845   }
66846   {
66847     try {
66848       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
66849     } catch (std::out_of_range& e) {
66850       {
66851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66852       };
66853     } catch (std::exception& e) {
66854       {
66855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66856       };
66857     } catch (...) {
66858       {
66859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66860       };
66861     }
66862   }
66863   jresult = (void *)result;
66864   return jresult;
66865 }
66866
66867
66868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
66869   void * jresult ;
66870   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66871   Dali::Toolkit::Model3dView *arg2 = 0 ;
66872   Dali::Toolkit::Model3dView *result = 0 ;
66873
66874   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66875   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
66876   if (!arg2) {
66877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66878     return 0;
66879   }
66880   {
66881     try {
66882       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
66883     } catch (std::out_of_range& e) {
66884       {
66885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66886       };
66887     } catch (std::exception& e) {
66888       {
66889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66890       };
66891     } catch (...) {
66892       {
66893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66894       };
66895     }
66896   }
66897   jresult = (void *)result;
66898   return jresult;
66899 }
66900
66901
66902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
66903   void * jresult ;
66904   Dali::BaseHandle arg1 ;
66905   Dali::BaseHandle *argp1 ;
66906   Dali::Toolkit::Model3dView result;
66907
66908   argp1 = (Dali::BaseHandle *)jarg1;
66909   if (!argp1) {
66910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66911     return 0;
66912   }
66913   arg1 = *argp1;
66914   {
66915     try {
66916       result = Dali::Toolkit::Model3dView::DownCast(arg1);
66917     } catch (std::out_of_range& e) {
66918       {
66919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66920       };
66921     } catch (std::exception& e) {
66922       {
66923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66924       };
66925     } catch (...) {
66926       {
66927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66928       };
66929     }
66930   }
66931   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66932   return jresult;
66933 }
66934
66935
66936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
66937   int jresult ;
66938   int result;
66939
66940   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
66941   jresult = (int)result;
66942   return jresult;
66943 }
66944
66945
66946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
66947   int jresult ;
66948   int result;
66949
66950   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
66951   jresult = (int)result;
66952   return jresult;
66953 }
66954
66955
66956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
66957   int jresult ;
66958   int result;
66959
66960   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
66961   jresult = (int)result;
66962   return jresult;
66963 }
66964
66965
66966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
66967   int jresult ;
66968   int result;
66969
66970   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
66971   jresult = (int)result;
66972   return jresult;
66973 }
66974
66975
66976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
66977   int jresult ;
66978   int result;
66979
66980   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
66981   jresult = (int)result;
66982   return jresult;
66983 }
66984
66985
66986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
66987   int jresult ;
66988   int result;
66989
66990   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
66991   jresult = (int)result;
66992   return jresult;
66993 }
66994
66995
66996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
66997   int jresult ;
66998   int result;
66999
67000   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67001   jresult = (int)result;
67002   return jresult;
67003 }
67004
67005
67006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67007   int jresult ;
67008   int result;
67009
67010   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67011   jresult = (int)result;
67012   return jresult;
67013 }
67014
67015
67016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67017   int jresult ;
67018   int result;
67019
67020   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67021   jresult = (int)result;
67022   return jresult;
67023 }
67024
67025
67026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
67027   void * jresult ;
67028   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67029
67030   {
67031     try {
67032       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67033     } catch (std::out_of_range& e) {
67034       {
67035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67036       };
67037     } catch (std::exception& e) {
67038       {
67039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67040       };
67041     } catch (...) {
67042       {
67043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67044       };
67045     }
67046   }
67047   jresult = (void *)result;
67048   return jresult;
67049 }
67050
67051
67052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
67053   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67054
67055   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67056   {
67057     try {
67058       delete arg1;
67059     } catch (std::out_of_range& e) {
67060       {
67061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67062       };
67063     } catch (std::exception& e) {
67064       {
67065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67066       };
67067     } catch (...) {
67068       {
67069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67070       };
67071     }
67072   }
67073 }
67074
67075
67076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
67077   void * jresult ;
67078   Dali::Toolkit::ScrollBar *result = 0 ;
67079
67080   {
67081     try {
67082       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
67083     } catch (std::out_of_range& e) {
67084       {
67085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67086       };
67087     } catch (std::exception& e) {
67088       {
67089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67090       };
67091     } catch (...) {
67092       {
67093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67094       };
67095     }
67096   }
67097   jresult = (void *)result;
67098   return jresult;
67099 }
67100
67101
67102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
67103   void * jresult ;
67104   Dali::Toolkit::ScrollBar *arg1 = 0 ;
67105   Dali::Toolkit::ScrollBar *result = 0 ;
67106
67107   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67108   if (!arg1) {
67109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67110     return 0;
67111   }
67112   {
67113     try {
67114       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
67115     } catch (std::out_of_range& e) {
67116       {
67117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67118       };
67119     } catch (std::exception& e) {
67120       {
67121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67122       };
67123     } catch (...) {
67124       {
67125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67126       };
67127     }
67128   }
67129   jresult = (void *)result;
67130   return jresult;
67131 }
67132
67133
67134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
67135   void * jresult ;
67136   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67137   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67138   Dali::Toolkit::ScrollBar *result = 0 ;
67139
67140   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67141   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67142   if (!arg2) {
67143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67144     return 0;
67145   }
67146   {
67147     try {
67148       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67149     } catch (std::out_of_range& e) {
67150       {
67151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67152       };
67153     } catch (std::exception& e) {
67154       {
67155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67156       };
67157     } catch (...) {
67158       {
67159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67160       };
67161     }
67162   }
67163   jresult = (void *)result;
67164   return jresult;
67165 }
67166
67167
67168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67169   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67170
67171   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67172   {
67173     try {
67174       delete arg1;
67175     } catch (std::out_of_range& e) {
67176       {
67177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67178       };
67179     } catch (std::exception& e) {
67180       {
67181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67182       };
67183     } catch (...) {
67184       {
67185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67186       };
67187     }
67188   }
67189 }
67190
67191
67192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
67193   void * jresult ;
67194   Dali::Toolkit::ScrollBar::Direction arg1 ;
67195   Dali::Toolkit::ScrollBar result;
67196
67197   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67198   {
67199     try {
67200       result = Dali::Toolkit::ScrollBar::New(arg1);
67201     } catch (std::out_of_range& e) {
67202       {
67203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67204       };
67205     } catch (std::exception& e) {
67206       {
67207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67208       };
67209     } catch (...) {
67210       {
67211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67212       };
67213     }
67214   }
67215   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67216   return jresult;
67217 }
67218
67219
67220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
67221   void * jresult ;
67222   Dali::Toolkit::ScrollBar result;
67223
67224   {
67225     try {
67226       result = Dali::Toolkit::ScrollBar::New();
67227     } catch (std::out_of_range& e) {
67228       {
67229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67230       };
67231     } catch (std::exception& e) {
67232       {
67233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67234       };
67235     } catch (...) {
67236       {
67237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67238       };
67239     }
67240   }
67241   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67242   return jresult;
67243 }
67244
67245
67246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67247   void * jresult ;
67248   Dali::BaseHandle arg1 ;
67249   Dali::BaseHandle *argp1 ;
67250   Dali::Toolkit::ScrollBar result;
67251
67252   argp1 = (Dali::BaseHandle *)jarg1;
67253   if (!argp1) {
67254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67255     return 0;
67256   }
67257   arg1 = *argp1;
67258   {
67259     try {
67260       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67261     } catch (std::out_of_range& e) {
67262       {
67263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67264       };
67265     } catch (std::exception& e) {
67266       {
67267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67268       };
67269     } catch (...) {
67270       {
67271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67272       };
67273     }
67274   }
67275   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67276   return jresult;
67277 }
67278
67279
67280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67281   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67282   Dali::Handle arg2 ;
67283   Dali::Property::Index arg3 ;
67284   Dali::Property::Index arg4 ;
67285   Dali::Property::Index arg5 ;
67286   Dali::Property::Index arg6 ;
67287   Dali::Handle *argp2 ;
67288
67289   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67290   argp2 = (Dali::Handle *)jarg2;
67291   if (!argp2) {
67292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67293     return ;
67294   }
67295   arg2 = *argp2;
67296   arg3 = (Dali::Property::Index)jarg3;
67297   arg4 = (Dali::Property::Index)jarg4;
67298   arg5 = (Dali::Property::Index)jarg5;
67299   arg6 = (Dali::Property::Index)jarg6;
67300   {
67301     try {
67302       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
67303     } catch (std::out_of_range& e) {
67304       {
67305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67306       };
67307     } catch (std::exception& e) {
67308       {
67309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67310       };
67311     } catch (...) {
67312       {
67313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67314       };
67315     }
67316   }
67317 }
67318
67319
67320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67321   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67322   Dali::Actor arg2 ;
67323   Dali::Actor *argp2 ;
67324
67325   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67326   argp2 = (Dali::Actor *)jarg2;
67327   if (!argp2) {
67328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67329     return ;
67330   }
67331   arg2 = *argp2;
67332   {
67333     try {
67334       (arg1)->SetScrollIndicator(arg2);
67335     } catch (std::out_of_range& e) {
67336       {
67337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67338       };
67339     } catch (std::exception& e) {
67340       {
67341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67342       };
67343     } catch (...) {
67344       {
67345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67346       };
67347     }
67348   }
67349 }
67350
67351
67352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
67353   void * jresult ;
67354   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67355   Dali::Actor result;
67356
67357   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67358   {
67359     try {
67360       result = (arg1)->GetScrollIndicator();
67361     } catch (std::out_of_range& e) {
67362       {
67363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67364       };
67365     } catch (std::exception& e) {
67366       {
67367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67368       };
67369     } catch (...) {
67370       {
67371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67372       };
67373     }
67374   }
67375   jresult = new Dali::Actor((const Dali::Actor &)result);
67376   return jresult;
67377 }
67378
67379
67380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
67381   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67382   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
67383
67384   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67385   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
67386   if (!arg2) {
67387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
67388     return ;
67389   }
67390   {
67391     try {
67392       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
67393     } catch (std::out_of_range& e) {
67394       {
67395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67396       };
67397     } catch (std::exception& e) {
67398       {
67399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67400       };
67401     } catch (...) {
67402       {
67403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67404       };
67405     }
67406   }
67407 }
67408
67409
67410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
67411   void * jresult ;
67412   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67413   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
67414
67415   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67416   {
67417     try {
67418       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
67419     } catch (std::out_of_range& e) {
67420       {
67421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67422       };
67423     } catch (std::exception& e) {
67424       {
67425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67426       };
67427     } catch (...) {
67428       {
67429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67430       };
67431     }
67432   }
67433   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
67434   return jresult;
67435 }
67436
67437
67438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
67439   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67440   Dali::Toolkit::ScrollBar::Direction arg2 ;
67441
67442   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67443   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
67444   {
67445     try {
67446       (arg1)->SetScrollDirection(arg2);
67447     } catch (std::out_of_range& e) {
67448       {
67449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67450       };
67451     } catch (std::exception& e) {
67452       {
67453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67454       };
67455     } catch (...) {
67456       {
67457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67458       };
67459     }
67460   }
67461 }
67462
67463
67464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
67465   int jresult ;
67466   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67467   Dali::Toolkit::ScrollBar::Direction result;
67468
67469   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67470   {
67471     try {
67472       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
67473     } catch (std::out_of_range& e) {
67474       {
67475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67476       };
67477     } catch (std::exception& e) {
67478       {
67479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67480       };
67481     } catch (...) {
67482       {
67483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67484       };
67485     }
67486   }
67487   jresult = (int)result;
67488   return jresult;
67489 }
67490
67491
67492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
67493   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67494   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
67495
67496   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67497   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
67498   {
67499     try {
67500       (arg1)->SetIndicatorHeightPolicy(arg2);
67501     } catch (std::out_of_range& e) {
67502       {
67503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67504       };
67505     } catch (std::exception& e) {
67506       {
67507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67508       };
67509     } catch (...) {
67510       {
67511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67512       };
67513     }
67514   }
67515 }
67516
67517
67518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
67519   int jresult ;
67520   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67521   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
67522
67523   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67524   {
67525     try {
67526       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
67527     } catch (std::out_of_range& e) {
67528       {
67529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67530       };
67531     } catch (std::exception& e) {
67532       {
67533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67534       };
67535     } catch (...) {
67536       {
67537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67538       };
67539     }
67540   }
67541   jresult = (int)result;
67542   return jresult;
67543 }
67544
67545
67546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
67547   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67548   float arg2 ;
67549
67550   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67551   arg2 = (float)jarg2;
67552   {
67553     try {
67554       (arg1)->SetIndicatorFixedHeight(arg2);
67555     } catch (std::out_of_range& e) {
67556       {
67557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67558       };
67559     } catch (std::exception& e) {
67560       {
67561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67562       };
67563     } catch (...) {
67564       {
67565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67566       };
67567     }
67568   }
67569 }
67570
67571
67572 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
67573   float jresult ;
67574   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67575   float result;
67576
67577   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67578   {
67579     try {
67580       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
67581     } catch (std::out_of_range& e) {
67582       {
67583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67584       };
67585     } catch (std::exception& e) {
67586       {
67587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67588       };
67589     } catch (...) {
67590       {
67591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67592       };
67593     }
67594   }
67595   jresult = result;
67596   return jresult;
67597 }
67598
67599
67600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
67601   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67602   float arg2 ;
67603
67604   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67605   arg2 = (float)jarg2;
67606   {
67607     try {
67608       (arg1)->SetIndicatorShowDuration(arg2);
67609     } catch (std::out_of_range& e) {
67610       {
67611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67612       };
67613     } catch (std::exception& e) {
67614       {
67615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67616       };
67617     } catch (...) {
67618       {
67619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67620       };
67621     }
67622   }
67623 }
67624
67625
67626 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
67627   float jresult ;
67628   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67629   float result;
67630
67631   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67632   {
67633     try {
67634       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
67635     } catch (std::out_of_range& e) {
67636       {
67637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67638       };
67639     } catch (std::exception& e) {
67640       {
67641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67642       };
67643     } catch (...) {
67644       {
67645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67646       };
67647     }
67648   }
67649   jresult = result;
67650   return jresult;
67651 }
67652
67653
67654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
67655   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67656   float arg2 ;
67657
67658   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67659   arg2 = (float)jarg2;
67660   {
67661     try {
67662       (arg1)->SetIndicatorHideDuration(arg2);
67663     } catch (std::out_of_range& e) {
67664       {
67665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67666       };
67667     } catch (std::exception& e) {
67668       {
67669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67670       };
67671     } catch (...) {
67672       {
67673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67674       };
67675     }
67676   }
67677 }
67678
67679
67680 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
67681   float jresult ;
67682   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67683   float result;
67684
67685   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67686   {
67687     try {
67688       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
67689     } catch (std::out_of_range& e) {
67690       {
67691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67692       };
67693     } catch (std::exception& e) {
67694       {
67695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67696       };
67697     } catch (...) {
67698       {
67699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67700       };
67701     }
67702   }
67703   jresult = result;
67704   return jresult;
67705 }
67706
67707
67708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
67709   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67710
67711   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67712   {
67713     try {
67714       (arg1)->ShowIndicator();
67715     } catch (std::out_of_range& e) {
67716       {
67717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67718       };
67719     } catch (std::exception& e) {
67720       {
67721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67722       };
67723     } catch (...) {
67724       {
67725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67726       };
67727     }
67728   }
67729 }
67730
67731
67732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
67733   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67734
67735   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67736   {
67737     try {
67738       (arg1)->HideIndicator();
67739     } catch (std::out_of_range& e) {
67740       {
67741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67742       };
67743     } catch (std::exception& e) {
67744       {
67745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67746       };
67747     } catch (...) {
67748       {
67749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67750       };
67751     }
67752   }
67753 }
67754
67755
67756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
67757   void * jresult ;
67758   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67759   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
67760
67761   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67762   {
67763     try {
67764       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
67765     } catch (std::out_of_range& e) {
67766       {
67767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67768       };
67769     } catch (std::exception& e) {
67770       {
67771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67772       };
67773     } catch (...) {
67774       {
67775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67776       };
67777     }
67778   }
67779   jresult = (void *)result;
67780   return jresult;
67781 }
67782
67783
67784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
67785   void * jresult ;
67786   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67787   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
67788
67789   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67790   {
67791     try {
67792       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
67793     } catch (std::out_of_range& e) {
67794       {
67795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67796       };
67797     } catch (std::exception& e) {
67798       {
67799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67800       };
67801     } catch (...) {
67802       {
67803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67804       };
67805     }
67806   }
67807   jresult = (void *)result;
67808   return jresult;
67809 }
67810
67811
67812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
67813   int jresult ;
67814   int result;
67815
67816   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
67817   jresult = (int)result;
67818   return jresult;
67819 }
67820
67821
67822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
67823   int jresult ;
67824   int result;
67825
67826   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
67827   jresult = (int)result;
67828   return jresult;
67829 }
67830
67831
67832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
67833   int jresult ;
67834   int result;
67835
67836   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
67837   jresult = (int)result;
67838   return jresult;
67839 }
67840
67841
67842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
67843   int jresult ;
67844   int result;
67845
67846   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
67847   jresult = (int)result;
67848   return jresult;
67849 }
67850
67851
67852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
67853   int jresult ;
67854   int result;
67855
67856   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
67857   jresult = (int)result;
67858   return jresult;
67859 }
67860
67861
67862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
67863   int jresult ;
67864   int result;
67865
67866   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
67867   jresult = (int)result;
67868   return jresult;
67869 }
67870
67871
67872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
67873   int jresult ;
67874   int result;
67875
67876   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
67877   jresult = (int)result;
67878   return jresult;
67879 }
67880
67881
67882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
67883   int jresult ;
67884   int result;
67885
67886   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
67887   jresult = (int)result;
67888   return jresult;
67889 }
67890
67891
67892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
67893   int jresult ;
67894   int result;
67895
67896   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
67897   jresult = (int)result;
67898   return jresult;
67899 }
67900
67901
67902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
67903   int jresult ;
67904   int result;
67905
67906   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
67907   jresult = (int)result;
67908   return jresult;
67909 }
67910
67911
67912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
67913   int jresult ;
67914   int result;
67915
67916   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
67917   jresult = (int)result;
67918   return jresult;
67919 }
67920
67921
67922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
67923   int jresult ;
67924   int result;
67925
67926   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
67927   jresult = (int)result;
67928   return jresult;
67929 }
67930
67931
67932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
67933   int jresult ;
67934   int result;
67935
67936   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
67937   jresult = (int)result;
67938   return jresult;
67939 }
67940
67941
67942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
67943   int jresult ;
67944   int result;
67945
67946   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
67947   jresult = (int)result;
67948   return jresult;
67949 }
67950
67951
67952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
67953   void * jresult ;
67954   Dali::Toolkit::Scrollable::Property *result = 0 ;
67955
67956   {
67957     try {
67958       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
67959     } catch (std::out_of_range& e) {
67960       {
67961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67962       };
67963     } catch (std::exception& e) {
67964       {
67965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67966       };
67967     } catch (...) {
67968       {
67969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67970       };
67971     }
67972   }
67973   jresult = (void *)result;
67974   return jresult;
67975 }
67976
67977
67978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
67979   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
67980
67981   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
67982   {
67983     try {
67984       delete arg1;
67985     } catch (std::out_of_range& e) {
67986       {
67987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67988       };
67989     } catch (std::exception& e) {
67990       {
67991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67992       };
67993     } catch (...) {
67994       {
67995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67996       };
67997     }
67998   }
67999 }
68000
68001
68002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
68003   void * jresult ;
68004   Dali::Toolkit::Scrollable *result = 0 ;
68005
68006   {
68007     try {
68008       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68009     } catch (std::out_of_range& e) {
68010       {
68011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68012       };
68013     } catch (std::exception& e) {
68014       {
68015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68016       };
68017     } catch (...) {
68018       {
68019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68020       };
68021     }
68022   }
68023   jresult = (void *)result;
68024   return jresult;
68025 }
68026
68027
68028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
68029   void * jresult ;
68030   Dali::Toolkit::Scrollable *arg1 = 0 ;
68031   Dali::Toolkit::Scrollable *result = 0 ;
68032
68033   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68034   if (!arg1) {
68035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68036     return 0;
68037   }
68038   {
68039     try {
68040       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68041     } catch (std::out_of_range& e) {
68042       {
68043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68044       };
68045     } catch (std::exception& e) {
68046       {
68047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68048       };
68049     } catch (...) {
68050       {
68051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68052       };
68053     }
68054   }
68055   jresult = (void *)result;
68056   return jresult;
68057 }
68058
68059
68060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
68061   void * jresult ;
68062   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68063   Dali::Toolkit::Scrollable *arg2 = 0 ;
68064   Dali::Toolkit::Scrollable *result = 0 ;
68065
68066   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68067   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
68068   if (!arg2) {
68069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68070     return 0;
68071   }
68072   {
68073     try {
68074       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
68075     } catch (std::out_of_range& e) {
68076       {
68077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68078       };
68079     } catch (std::exception& e) {
68080       {
68081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68082       };
68083     } catch (...) {
68084       {
68085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68086       };
68087     }
68088   }
68089   jresult = (void *)result;
68090   return jresult;
68091 }
68092
68093
68094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
68095   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68096
68097   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68098   {
68099     try {
68100       delete arg1;
68101     } catch (std::out_of_range& e) {
68102       {
68103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68104       };
68105     } catch (std::exception& e) {
68106       {
68107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68108       };
68109     } catch (...) {
68110       {
68111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68112       };
68113     }
68114   }
68115 }
68116
68117
68118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
68119   void * jresult ;
68120   Dali::BaseHandle arg1 ;
68121   Dali::BaseHandle *argp1 ;
68122   Dali::Toolkit::Scrollable result;
68123
68124   argp1 = (Dali::BaseHandle *)jarg1;
68125   if (!argp1) {
68126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68127     return 0;
68128   }
68129   arg1 = *argp1;
68130   {
68131     try {
68132       result = Dali::Toolkit::Scrollable::DownCast(arg1);
68133     } catch (std::out_of_range& e) {
68134       {
68135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68136       };
68137     } catch (std::exception& e) {
68138       {
68139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68140       };
68141     } catch (...) {
68142       {
68143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68144       };
68145     }
68146   }
68147   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68148   return jresult;
68149 }
68150
68151
68152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
68153   unsigned int jresult ;
68154   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68155   bool result;
68156
68157   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68158   {
68159     try {
68160       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68161     } catch (std::out_of_range& e) {
68162       {
68163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68164       };
68165     } catch (std::exception& e) {
68166       {
68167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68168       };
68169     } catch (...) {
68170       {
68171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68172       };
68173     }
68174   }
68175   jresult = result;
68176   return jresult;
68177 }
68178
68179
68180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68181   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68182   bool arg2 ;
68183
68184   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68185   arg2 = jarg2 ? true : false;
68186   {
68187     try {
68188       (arg1)->SetOvershootEnabled(arg2);
68189     } catch (std::out_of_range& e) {
68190       {
68191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68192       };
68193     } catch (std::exception& e) {
68194       {
68195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68196       };
68197     } catch (...) {
68198       {
68199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68200       };
68201     }
68202   }
68203 }
68204
68205
68206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
68207   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68208   Dali::Vector4 *arg2 = 0 ;
68209
68210   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68211   arg2 = (Dali::Vector4 *)jarg2;
68212   if (!arg2) {
68213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68214     return ;
68215   }
68216   {
68217     try {
68218       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
68219     } catch (std::out_of_range& e) {
68220       {
68221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68222       };
68223     } catch (std::exception& e) {
68224       {
68225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68226       };
68227     } catch (...) {
68228       {
68229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68230       };
68231     }
68232   }
68233 }
68234
68235
68236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
68237   void * jresult ;
68238   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68239   Dali::Vector4 result;
68240
68241   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68242   {
68243     try {
68244       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68245     } catch (std::out_of_range& e) {
68246       {
68247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68248       };
68249     } catch (std::exception& e) {
68250       {
68251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68252       };
68253     } catch (...) {
68254       {
68255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68256       };
68257     }
68258   }
68259   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68260   return jresult;
68261 }
68262
68263
68264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68265   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68266   float arg2 ;
68267
68268   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68269   arg2 = (float)jarg2;
68270   {
68271     try {
68272       (arg1)->SetOvershootAnimationSpeed(arg2);
68273     } catch (std::out_of_range& e) {
68274       {
68275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68276       };
68277     } catch (std::exception& e) {
68278       {
68279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68280       };
68281     } catch (...) {
68282       {
68283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68284       };
68285     }
68286   }
68287 }
68288
68289
68290 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
68291   float jresult ;
68292   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68293   float result;
68294
68295   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68296   {
68297     try {
68298       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
68299     } catch (std::out_of_range& e) {
68300       {
68301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68302       };
68303     } catch (std::exception& e) {
68304       {
68305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68306       };
68307     } catch (...) {
68308       {
68309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68310       };
68311     }
68312   }
68313   jresult = result;
68314   return jresult;
68315 }
68316
68317
68318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
68319   void * jresult ;
68320   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68321   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
68322
68323   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68324   {
68325     try {
68326       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
68327     } catch (std::out_of_range& e) {
68328       {
68329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68330       };
68331     } catch (std::exception& e) {
68332       {
68333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68334       };
68335     } catch (...) {
68336       {
68337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68338       };
68339     }
68340   }
68341   jresult = (void *)result;
68342   return jresult;
68343 }
68344
68345
68346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
68347   void * jresult ;
68348   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68349   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
68350
68351   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68352   {
68353     try {
68354       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
68355     } catch (std::out_of_range& e) {
68356       {
68357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68358       };
68359     } catch (std::exception& e) {
68360       {
68361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68362       };
68363     } catch (...) {
68364       {
68365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68366       };
68367     }
68368   }
68369   jresult = (void *)result;
68370   return jresult;
68371 }
68372
68373
68374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
68375   void * jresult ;
68376   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68377   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
68378
68379   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68380   {
68381     try {
68382       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
68383     } catch (std::out_of_range& e) {
68384       {
68385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68386       };
68387     } catch (std::exception& e) {
68388       {
68389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68390       };
68391     } catch (...) {
68392       {
68393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68394       };
68395     }
68396   }
68397   jresult = (void *)result;
68398   return jresult;
68399 }
68400
68401
68402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
68403   unsigned int jresult ;
68404   Dali::Toolkit::ControlOrientation::Type arg1 ;
68405   bool result;
68406
68407   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68408   {
68409     try {
68410       result = (bool)Dali::Toolkit::IsVertical(arg1);
68411     } catch (std::out_of_range& e) {
68412       {
68413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68414       };
68415     } catch (std::exception& e) {
68416       {
68417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68418       };
68419     } catch (...) {
68420       {
68421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68422       };
68423     }
68424   }
68425   jresult = result;
68426   return jresult;
68427 }
68428
68429
68430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
68431   unsigned int jresult ;
68432   Dali::Toolkit::ControlOrientation::Type arg1 ;
68433   bool result;
68434
68435   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68436   {
68437     try {
68438       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
68439     } catch (std::out_of_range& e) {
68440       {
68441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68442       };
68443     } catch (std::exception& e) {
68444       {
68445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68446       };
68447     } catch (...) {
68448       {
68449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68450       };
68451     }
68452   }
68453   jresult = result;
68454   return jresult;
68455 }
68456
68457
68458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
68459   void * jresult ;
68460   unsigned int arg1 ;
68461   unsigned int arg2 ;
68462   Dali::Toolkit::ItemRange *result = 0 ;
68463
68464   arg1 = (unsigned int)jarg1;
68465   arg2 = (unsigned int)jarg2;
68466   {
68467     try {
68468       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
68469     } catch (std::out_of_range& e) {
68470       {
68471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68472       };
68473     } catch (std::exception& e) {
68474       {
68475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68476       };
68477     } catch (...) {
68478       {
68479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68480       };
68481     }
68482   }
68483   jresult = (void *)result;
68484   return jresult;
68485 }
68486
68487
68488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
68489   void * jresult ;
68490   Dali::Toolkit::ItemRange *arg1 = 0 ;
68491   Dali::Toolkit::ItemRange *result = 0 ;
68492
68493   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68494   if (!arg1) {
68495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68496     return 0;
68497   }
68498   {
68499     try {
68500       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
68501     } catch (std::out_of_range& e) {
68502       {
68503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68504       };
68505     } catch (std::exception& e) {
68506       {
68507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68508       };
68509     } catch (...) {
68510       {
68511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68512       };
68513     }
68514   }
68515   jresult = (void *)result;
68516   return jresult;
68517 }
68518
68519
68520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
68521   void * jresult ;
68522   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68523   Dali::Toolkit::ItemRange *arg2 = 0 ;
68524   Dali::Toolkit::ItemRange *result = 0 ;
68525
68526   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68527   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68528   if (!arg2) {
68529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68530     return 0;
68531   }
68532   {
68533     try {
68534       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
68535     } catch (std::out_of_range& e) {
68536       {
68537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68538       };
68539     } catch (std::exception& e) {
68540       {
68541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68542       };
68543     } catch (...) {
68544       {
68545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68546       };
68547     }
68548   }
68549   jresult = (void *)result;
68550   return jresult;
68551 }
68552
68553
68554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
68555   unsigned int jresult ;
68556   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68557   unsigned int arg2 ;
68558   bool result;
68559
68560   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68561   arg2 = (unsigned int)jarg2;
68562   {
68563     try {
68564       result = (bool)(arg1)->Within(arg2);
68565     } catch (std::out_of_range& e) {
68566       {
68567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68568       };
68569     } catch (std::exception& e) {
68570       {
68571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68572       };
68573     } catch (...) {
68574       {
68575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68576       };
68577     }
68578   }
68579   jresult = result;
68580   return jresult;
68581 }
68582
68583
68584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
68585   void * jresult ;
68586   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68587   Dali::Toolkit::ItemRange *arg2 = 0 ;
68588   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68589
68590   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68591   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68592   if (!arg2) {
68593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68594     return 0;
68595   }
68596   {
68597     try {
68598       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
68599     } catch (std::out_of_range& e) {
68600       {
68601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68602       };
68603     } catch (std::exception& e) {
68604       {
68605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68606       };
68607     } catch (...) {
68608       {
68609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68610       };
68611     }
68612   }
68613   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
68614   return jresult;
68615 }
68616
68617
68618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
68619   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68620   unsigned int arg2 ;
68621
68622   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68623   arg2 = (unsigned int)jarg2;
68624   if (arg1) (arg1)->begin = arg2;
68625 }
68626
68627
68628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
68629   unsigned int jresult ;
68630   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68631   unsigned int result;
68632
68633   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68634   result = (unsigned int) ((arg1)->begin);
68635   jresult = result;
68636   return jresult;
68637 }
68638
68639
68640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
68641   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68642   unsigned int arg2 ;
68643
68644   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68645   arg2 = (unsigned int)jarg2;
68646   if (arg1) (arg1)->end = arg2;
68647 }
68648
68649
68650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
68651   unsigned int jresult ;
68652   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68653   unsigned int result;
68654
68655   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68656   result = (unsigned int) ((arg1)->end);
68657   jresult = result;
68658   return jresult;
68659 }
68660
68661
68662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
68663   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68664
68665   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68666   {
68667     try {
68668       delete arg1;
68669     } catch (std::out_of_range& e) {
68670       {
68671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68672       };
68673     } catch (std::exception& e) {
68674       {
68675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68676       };
68677     } catch (...) {
68678       {
68679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68680       };
68681     }
68682   }
68683 }
68684
68685
68686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
68687   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68688
68689   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68690   {
68691     try {
68692       delete arg1;
68693     } catch (std::out_of_range& e) {
68694       {
68695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68696       };
68697     } catch (std::exception& e) {
68698       {
68699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68700       };
68701     } catch (...) {
68702       {
68703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68704       };
68705     }
68706   }
68707 }
68708
68709
68710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
68711   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68712   Dali::Toolkit::ControlOrientation::Type arg2 ;
68713
68714   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68715   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
68716   {
68717     try {
68718       (arg1)->SetOrientation(arg2);
68719     } catch (std::out_of_range& e) {
68720       {
68721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68722       };
68723     } catch (std::exception& e) {
68724       {
68725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68726       };
68727     } catch (...) {
68728       {
68729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68730       };
68731     }
68732   }
68733 }
68734
68735
68736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
68737   int jresult ;
68738   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68739   Dali::Toolkit::ControlOrientation::Type result;
68740
68741   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68742   {
68743     try {
68744       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
68745     } catch (std::out_of_range& e) {
68746       {
68747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68748       };
68749     } catch (std::exception& e) {
68750       {
68751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68752       };
68753     } catch (...) {
68754       {
68755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68756       };
68757     }
68758   }
68759   jresult = (int)result;
68760   return jresult;
68761 }
68762
68763
68764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
68765   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68766   Dali::Property::Map *arg2 = 0 ;
68767
68768   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68769   arg2 = (Dali::Property::Map *)jarg2;
68770   if (!arg2) {
68771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
68772     return ;
68773   }
68774   {
68775     try {
68776       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
68777     } catch (std::out_of_range& e) {
68778       {
68779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68780       };
68781     } catch (std::exception& e) {
68782       {
68783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68784       };
68785     } catch (...) {
68786       {
68787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68788       };
68789     }
68790   }
68791 }
68792
68793
68794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
68795   void * jresult ;
68796   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68797   Dali::Property::Map result;
68798
68799   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68800   {
68801     try {
68802       result = (arg1)->GetLayoutProperties();
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 = new Dali::Property::Map((const Dali::Property::Map &)result);
68818   return jresult;
68819 }
68820
68821
68822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
68823   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68824   unsigned int arg2 ;
68825   Dali::Vector3 *arg3 = 0 ;
68826   Dali::Vector3 *arg4 = 0 ;
68827
68828   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68829   arg2 = (unsigned int)jarg2;
68830   arg3 = (Dali::Vector3 *)jarg3;
68831   if (!arg3) {
68832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68833     return ;
68834   }
68835   arg4 = (Dali::Vector3 *)jarg4;
68836   if (!arg4) {
68837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
68838     return ;
68839   }
68840   {
68841     try {
68842       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
68843     } catch (std::out_of_range& e) {
68844       {
68845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68846       };
68847     } catch (std::exception& e) {
68848       {
68849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68850       };
68851     } catch (...) {
68852       {
68853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68854       };
68855     }
68856   }
68857 }
68858
68859
68860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
68861   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68862   Dali::Vector3 *arg2 = 0 ;
68863
68864   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68865   arg2 = (Dali::Vector3 *)jarg2;
68866   if (!arg2) {
68867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68868     return ;
68869   }
68870   {
68871     try {
68872       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
68873     } catch (std::out_of_range& e) {
68874       {
68875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68876       };
68877     } catch (std::exception& e) {
68878       {
68879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68880       };
68881     } catch (...) {
68882       {
68883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68884       };
68885     }
68886   }
68887 }
68888
68889
68890 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
68891   float jresult ;
68892   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68893   unsigned int arg2 ;
68894   Dali::Vector3 arg3 ;
68895   Dali::Vector3 *argp3 ;
68896   float result;
68897
68898   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68899   arg2 = (unsigned int)jarg2;
68900   argp3 = (Dali::Vector3 *)jarg3;
68901   if (!argp3) {
68902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68903     return 0;
68904   }
68905   arg3 = *argp3;
68906   {
68907     try {
68908       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
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 float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
68929   float jresult ;
68930   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68931   float arg2 ;
68932   float result;
68933
68934   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68935   arg2 = (float)jarg2;
68936   {
68937     try {
68938       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
68939     } catch (std::out_of_range& e) {
68940       {
68941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68942       };
68943     } catch (std::exception& e) {
68944       {
68945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68946       };
68947     } catch (...) {
68948       {
68949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68950       };
68951     }
68952   }
68953   jresult = result;
68954   return jresult;
68955 }
68956
68957
68958 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
68959   float jresult ;
68960   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68961   unsigned int arg2 ;
68962   float result;
68963
68964   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68965   arg2 = (unsigned int)jarg2;
68966   {
68967     try {
68968       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
68969     } catch (std::out_of_range& e) {
68970       {
68971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68972       };
68973     } catch (std::exception& e) {
68974       {
68975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68976       };
68977     } catch (...) {
68978       {
68979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68980       };
68981     }
68982   }
68983   jresult = result;
68984   return jresult;
68985 }
68986
68987
68988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
68989   void * jresult ;
68990   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68991   float arg2 ;
68992   Dali::Vector3 arg3 ;
68993   Dali::Vector3 *argp3 ;
68994   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68995
68996   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68997   arg2 = (float)jarg2;
68998   argp3 = (Dali::Vector3 *)jarg3;
68999   if (!argp3) {
69000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69001     return 0;
69002   }
69003   arg3 = *argp3;
69004   {
69005     try {
69006       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69007     } catch (std::out_of_range& e) {
69008       {
69009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69010       };
69011     } catch (std::exception& e) {
69012       {
69013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69014       };
69015     } catch (...) {
69016       {
69017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69018       };
69019     }
69020   }
69021   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69022   return jresult;
69023 }
69024
69025
69026 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69027   float jresult ;
69028   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69029   int arg2 ;
69030   float arg3 ;
69031   Dali::Vector3 *arg4 = 0 ;
69032   float result;
69033
69034   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69035   arg2 = (int)jarg2;
69036   arg3 = (float)jarg3;
69037   arg4 = (Dali::Vector3 *)jarg4;
69038   if (!arg4) {
69039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69040     return 0;
69041   }
69042   {
69043     try {
69044       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69045     } catch (std::out_of_range& e) {
69046       {
69047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69048       };
69049     } catch (std::exception& e) {
69050       {
69051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69052       };
69053     } catch (...) {
69054       {
69055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69056       };
69057     }
69058   }
69059   jresult = result;
69060   return jresult;
69061 }
69062
69063
69064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
69065   unsigned int jresult ;
69066   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69067   Dali::Vector3 arg2 ;
69068   Dali::Vector3 *argp2 ;
69069   unsigned int result;
69070
69071   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69072   argp2 = (Dali::Vector3 *)jarg2;
69073   if (!argp2) {
69074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69075     return 0;
69076   }
69077   arg2 = *argp2;
69078   {
69079     try {
69080       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
69081     } catch (std::out_of_range& e) {
69082       {
69083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69084       };
69085     } catch (std::exception& e) {
69086       {
69087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69088       };
69089     } catch (...) {
69090       {
69091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69092       };
69093     }
69094   }
69095   jresult = result;
69096   return jresult;
69097 }
69098
69099
69100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69101   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69102   unsigned int arg2 ;
69103   Dali::Vector3 *arg3 = 0 ;
69104   Dali::Vector3 *arg4 = 0 ;
69105
69106   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69107   arg2 = (unsigned int)jarg2;
69108   arg3 = (Dali::Vector3 *)jarg3;
69109   if (!arg3) {
69110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69111     return ;
69112   }
69113   arg4 = (Dali::Vector3 *)jarg4;
69114   if (!arg4) {
69115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69116     return ;
69117   }
69118   {
69119     try {
69120       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69121     } catch (std::out_of_range& e) {
69122       {
69123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69124       };
69125     } catch (std::exception& e) {
69126       {
69127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69128       };
69129     } catch (...) {
69130       {
69131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69132       };
69133     }
69134   }
69135 }
69136
69137
69138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
69139   void * jresult ;
69140   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69141   Dali::Degree result;
69142
69143   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69144   {
69145     try {
69146       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
69147     } catch (std::out_of_range& e) {
69148       {
69149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69150       };
69151     } catch (std::exception& e) {
69152       {
69153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69154       };
69155     } catch (...) {
69156       {
69157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69158       };
69159     }
69160   }
69161   jresult = new Dali::Degree((const Dali::Degree &)result);
69162   return jresult;
69163 }
69164
69165
69166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
69167   float jresult ;
69168   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69169   float result;
69170
69171   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69172   {
69173     try {
69174       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
69175     } catch (std::out_of_range& e) {
69176       {
69177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69178       };
69179     } catch (std::exception& e) {
69180       {
69181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69182       };
69183     } catch (...) {
69184       {
69185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69186       };
69187     }
69188   }
69189   jresult = result;
69190   return jresult;
69191 }
69192
69193
69194 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
69195   float jresult ;
69196   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69197   float result;
69198
69199   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69200   {
69201     try {
69202       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
69203     } catch (std::out_of_range& e) {
69204       {
69205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69206       };
69207     } catch (std::exception& e) {
69208       {
69209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69210       };
69211     } catch (...) {
69212       {
69213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69214       };
69215     }
69216   }
69217   jresult = result;
69218   return jresult;
69219 }
69220
69221
69222 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
69223   float jresult ;
69224   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69225   float result;
69226
69227   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69228   {
69229     try {
69230       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
69231     } catch (std::out_of_range& e) {
69232       {
69233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69234       };
69235     } catch (std::exception& e) {
69236       {
69237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69238       };
69239     } catch (...) {
69240       {
69241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69242       };
69243     }
69244   }
69245   jresult = result;
69246   return jresult;
69247 }
69248
69249
69250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
69251   int jresult ;
69252   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69253   int arg2 ;
69254   int arg3 ;
69255   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
69256   bool arg5 ;
69257   int result;
69258
69259   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69260   arg2 = (int)jarg2;
69261   arg3 = (int)jarg3;
69262   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
69263   arg5 = jarg5 ? true : false;
69264   {
69265     try {
69266       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
69267     } catch (std::out_of_range& e) {
69268       {
69269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69270       };
69271     } catch (std::exception& e) {
69272       {
69273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69274       };
69275     } catch (...) {
69276       {
69277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69278       };
69279     }
69280   }
69281   jresult = result;
69282   return jresult;
69283 }
69284
69285
69286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
69287   float jresult ;
69288   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69289   float result;
69290
69291   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69292   {
69293     try {
69294       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
69295     } catch (std::out_of_range& e) {
69296       {
69297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69298       };
69299     } catch (std::exception& e) {
69300       {
69301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69302       };
69303     } catch (...) {
69304       {
69305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69306       };
69307     }
69308   }
69309   jresult = result;
69310   return jresult;
69311 }
69312
69313
69314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
69315   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69316   Dali::Actor *arg2 = 0 ;
69317   int arg3 ;
69318   Dali::Vector3 *arg4 = 0 ;
69319   Dali::Actor *arg5 = 0 ;
69320
69321   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69322   arg2 = (Dali::Actor *)jarg2;
69323   if (!arg2) {
69324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
69325     return ;
69326   }
69327   arg3 = (int)jarg3;
69328   arg4 = (Dali::Vector3 *)jarg4;
69329   if (!arg4) {
69330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69331     return ;
69332   }
69333   arg5 = (Dali::Actor *)jarg5;
69334   if (!arg5) {
69335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
69336     return ;
69337   }
69338   {
69339     try {
69340       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
69341     } catch (std::out_of_range& e) {
69342       {
69343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69344       };
69345     } catch (std::exception& e) {
69346       {
69347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69348       };
69349     } catch (...) {
69350       {
69351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69352       };
69353     }
69354   }
69355 }
69356
69357
69358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69359   void * jresult ;
69360   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69361   int arg2 ;
69362   float arg3 ;
69363   Dali::Vector3 *arg4 = 0 ;
69364   Dali::Vector3 result;
69365
69366   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69367   arg2 = (int)jarg2;
69368   arg3 = (float)jarg3;
69369   arg4 = (Dali::Vector3 *)jarg4;
69370   if (!arg4) {
69371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69372     return 0;
69373   }
69374   {
69375     try {
69376       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69377     } catch (std::out_of_range& e) {
69378       {
69379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69380       };
69381     } catch (std::exception& e) {
69382       {
69383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69384       };
69385     } catch (...) {
69386       {
69387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69388       };
69389     }
69390   }
69391   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
69392   return jresult;
69393 }
69394
69395
69396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
69397   void * jresult ;
69398   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
69399   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69400
69401   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
69402   {
69403     try {
69404       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
69405     } catch (std::out_of_range& e) {
69406       {
69407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69408       };
69409     } catch (std::exception& e) {
69410       {
69411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69412       };
69413     } catch (...) {
69414       {
69415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69416       };
69417     }
69418   }
69419   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69420   return jresult;
69421 }
69422
69423
69424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
69425   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69426
69427   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69428   {
69429     try {
69430       delete arg1;
69431     } catch (std::out_of_range& e) {
69432       {
69433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69434       };
69435     } catch (std::exception& e) {
69436       {
69437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69438       };
69439     } catch (...) {
69440       {
69441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69442       };
69443     }
69444   }
69445 }
69446
69447
69448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
69449   unsigned int jresult ;
69450   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69451   unsigned int result;
69452
69453   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69454   {
69455     try {
69456       result = (unsigned int)(arg1)->GetNumberOfItems();
69457     } catch (std::out_of_range& e) {
69458       {
69459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69460       };
69461     } catch (std::exception& e) {
69462       {
69463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69464       };
69465     } catch (...) {
69466       {
69467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69468       };
69469     }
69470   }
69471   jresult = result;
69472   return jresult;
69473 }
69474
69475
69476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
69477   void * jresult ;
69478   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69479   unsigned int arg2 ;
69480   Dali::Actor result;
69481
69482   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69483   arg2 = (unsigned int)jarg2;
69484   {
69485     try {
69486       result = (arg1)->NewItem(arg2);
69487     } catch (std::out_of_range& e) {
69488       {
69489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69490       };
69491     } catch (std::exception& e) {
69492       {
69493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69494       };
69495     } catch (...) {
69496       {
69497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69498       };
69499     }
69500   }
69501   jresult = new Dali::Actor((const Dali::Actor &)result);
69502   return jresult;
69503 }
69504
69505
69506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
69507   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69508   unsigned int arg2 ;
69509   Dali::Actor arg3 ;
69510   Dali::Actor *argp3 ;
69511
69512   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69513   arg2 = (unsigned int)jarg2;
69514   argp3 = (Dali::Actor *)jarg3;
69515   if (!argp3) {
69516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69517     return ;
69518   }
69519   arg3 = *argp3;
69520   {
69521     try {
69522       (arg1)->ItemReleased(arg2,arg3);
69523     } catch (std::out_of_range& e) {
69524       {
69525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69526       };
69527     } catch (std::exception& e) {
69528       {
69529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69530       };
69531     } catch (...) {
69532       {
69533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69534       };
69535     }
69536   }
69537 }
69538
69539
69540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
69541   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69542   unsigned int arg2 ;
69543   Dali::Actor arg3 ;
69544   Dali::Actor *argp3 ;
69545
69546   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69547   arg2 = (unsigned int)jarg2;
69548   argp3 = (Dali::Actor *)jarg3;
69549   if (!argp3) {
69550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69551     return ;
69552   }
69553   arg3 = *argp3;
69554   {
69555     try {
69556       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
69557     } catch (std::out_of_range& e) {
69558       {
69559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69560       };
69561     } catch (std::exception& e) {
69562       {
69563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69564       };
69565     } catch (...) {
69566       {
69567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69568       };
69569     }
69570   }
69571 }
69572
69573
69574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
69575   void * jresult ;
69576   Dali::Toolkit::ItemFactory *result = 0 ;
69577
69578   {
69579     try {
69580       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
69581     } catch (std::out_of_range& e) {
69582       {
69583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69584       };
69585     } catch (std::exception& e) {
69586       {
69587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69588       };
69589     } catch (...) {
69590       {
69591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69592       };
69593     }
69594   }
69595   jresult = (void *)result;
69596   return jresult;
69597 }
69598
69599
69600 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) {
69601   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
69602   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
69603   if (director) {
69604     director->swig_connect_director(callback0, callback1, callback2);
69605   }
69606 }
69607
69608
69609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
69610   int jresult ;
69611   int result;
69612
69613   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
69614   jresult = (int)result;
69615   return jresult;
69616 }
69617
69618
69619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
69620   int jresult ;
69621   int result;
69622
69623   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
69624   jresult = (int)result;
69625   return jresult;
69626 }
69627
69628
69629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
69630   int jresult ;
69631   int result;
69632
69633   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
69634   jresult = (int)result;
69635   return jresult;
69636 }
69637
69638
69639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
69640   int jresult ;
69641   int result;
69642
69643   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
69644   jresult = (int)result;
69645   return jresult;
69646 }
69647
69648
69649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
69650   int jresult ;
69651   int result;
69652
69653   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
69654   jresult = (int)result;
69655   return jresult;
69656 }
69657
69658
69659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
69660   int jresult ;
69661   int result;
69662
69663   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
69664   jresult = (int)result;
69665   return jresult;
69666 }
69667
69668
69669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
69670   int jresult ;
69671   int result;
69672
69673   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
69674   jresult = (int)result;
69675   return jresult;
69676 }
69677
69678
69679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
69680   int jresult ;
69681   int result;
69682
69683   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
69684   jresult = (int)result;
69685   return jresult;
69686 }
69687
69688
69689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
69690   int jresult ;
69691   int result;
69692
69693   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
69694   jresult = (int)result;
69695   return jresult;
69696 }
69697
69698
69699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
69700   int jresult ;
69701   int result;
69702
69703   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
69704   jresult = (int)result;
69705   return jresult;
69706 }
69707
69708
69709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
69710   int jresult ;
69711   int result;
69712
69713   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
69714   jresult = (int)result;
69715   return jresult;
69716 }
69717
69718
69719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
69720   void * jresult ;
69721   Dali::Toolkit::ItemView::Property *result = 0 ;
69722
69723   {
69724     try {
69725       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
69726     } catch (std::out_of_range& e) {
69727       {
69728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69729       };
69730     } catch (std::exception& e) {
69731       {
69732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69733       };
69734     } catch (...) {
69735       {
69736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69737       };
69738     }
69739   }
69740   jresult = (void *)result;
69741   return jresult;
69742 }
69743
69744
69745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
69746   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
69747
69748   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
69749   {
69750     try {
69751       delete arg1;
69752     } catch (std::out_of_range& e) {
69753       {
69754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69755       };
69756     } catch (std::exception& e) {
69757       {
69758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69759       };
69760     } catch (...) {
69761       {
69762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69763       };
69764     }
69765   }
69766 }
69767
69768
69769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
69770   void * jresult ;
69771   Dali::Toolkit::ItemView *result = 0 ;
69772
69773   {
69774     try {
69775       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
69776     } catch (std::out_of_range& e) {
69777       {
69778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69779       };
69780     } catch (std::exception& e) {
69781       {
69782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69783       };
69784     } catch (...) {
69785       {
69786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69787       };
69788     }
69789   }
69790   jresult = (void *)result;
69791   return jresult;
69792 }
69793
69794
69795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
69796   void * jresult ;
69797   Dali::Toolkit::ItemView *arg1 = 0 ;
69798   Dali::Toolkit::ItemView *result = 0 ;
69799
69800   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69801   if (!arg1) {
69802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
69803     return 0;
69804   }
69805   {
69806     try {
69807       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
69808     } catch (std::out_of_range& e) {
69809       {
69810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69811       };
69812     } catch (std::exception& e) {
69813       {
69814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69815       };
69816     } catch (...) {
69817       {
69818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69819       };
69820     }
69821   }
69822   jresult = (void *)result;
69823   return jresult;
69824 }
69825
69826
69827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
69828   void * jresult ;
69829   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69830   Dali::Toolkit::ItemView *arg2 = 0 ;
69831   Dali::Toolkit::ItemView *result = 0 ;
69832
69833   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69834   arg2 = (Dali::Toolkit::ItemView *)jarg2;
69835   if (!arg2) {
69836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
69837     return 0;
69838   }
69839   {
69840     try {
69841       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
69842     } catch (std::out_of_range& e) {
69843       {
69844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69845       };
69846     } catch (std::exception& e) {
69847       {
69848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69849       };
69850     } catch (...) {
69851       {
69852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69853       };
69854     }
69855   }
69856   jresult = (void *)result;
69857   return jresult;
69858 }
69859
69860
69861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
69862   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69863
69864   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69865   {
69866     try {
69867       delete arg1;
69868     } catch (std::out_of_range& e) {
69869       {
69870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69871       };
69872     } catch (std::exception& e) {
69873       {
69874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69875       };
69876     } catch (...) {
69877       {
69878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69879       };
69880     }
69881   }
69882 }
69883
69884
69885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
69886   void * jresult ;
69887   Dali::Toolkit::ItemFactory *arg1 = 0 ;
69888   Dali::Toolkit::ItemView result;
69889
69890   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69891   if (!arg1) {
69892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
69893     return 0;
69894   }
69895   {
69896     try {
69897       result = Dali::Toolkit::ItemView::New(*arg1);
69898     } catch (std::out_of_range& e) {
69899       {
69900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69901       };
69902     } catch (std::exception& e) {
69903       {
69904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69905       };
69906     } catch (...) {
69907       {
69908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69909       };
69910     }
69911   }
69912   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
69913   return jresult;
69914 }
69915
69916
69917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
69918   void * jresult ;
69919   Dali::BaseHandle arg1 ;
69920   Dali::BaseHandle *argp1 ;
69921   Dali::Toolkit::ItemView result;
69922
69923   argp1 = (Dali::BaseHandle *)jarg1;
69924   if (!argp1) {
69925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69926     return 0;
69927   }
69928   arg1 = *argp1;
69929   {
69930     try {
69931       result = Dali::Toolkit::ItemView::DownCast(arg1);
69932     } catch (std::out_of_range& e) {
69933       {
69934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69935       };
69936     } catch (std::exception& e) {
69937       {
69938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69939       };
69940     } catch (...) {
69941       {
69942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69943       };
69944     }
69945   }
69946   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
69947   return jresult;
69948 }
69949
69950
69951 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
69952   unsigned int jresult ;
69953   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69954   unsigned int result;
69955
69956   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69957   {
69958     try {
69959       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
69960     } catch (std::out_of_range& e) {
69961       {
69962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69963       };
69964     } catch (std::exception& e) {
69965       {
69966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69967       };
69968     } catch (...) {
69969       {
69970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69971       };
69972     }
69973   }
69974   jresult = result;
69975   return jresult;
69976 }
69977
69978
69979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
69980   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69981   Dali::Toolkit::ItemLayout *arg2 = 0 ;
69982
69983   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69984   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
69985   if (!arg2) {
69986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
69987     return ;
69988   }
69989   {
69990     try {
69991       (arg1)->AddLayout(*arg2);
69992     } catch (std::out_of_range& e) {
69993       {
69994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69995       };
69996     } catch (std::exception& e) {
69997       {
69998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69999       };
70000     } catch (...) {
70001       {
70002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70003       };
70004     }
70005   }
70006 }
70007
70008
70009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
70010   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70011   unsigned int arg2 ;
70012
70013   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70014   arg2 = (unsigned int)jarg2;
70015   {
70016     try {
70017       (arg1)->RemoveLayout(arg2);
70018     } catch (std::out_of_range& e) {
70019       {
70020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70021       };
70022     } catch (std::exception& e) {
70023       {
70024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70025       };
70026     } catch (...) {
70027       {
70028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70029       };
70030     }
70031   }
70032 }
70033
70034
70035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
70036   void * jresult ;
70037   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70038   unsigned int arg2 ;
70039   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70040
70041   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70042   arg2 = (unsigned int)jarg2;
70043   {
70044     try {
70045       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
70046     } catch (std::out_of_range& e) {
70047       {
70048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70049       };
70050     } catch (std::exception& e) {
70051       {
70052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70053       };
70054     } catch (...) {
70055       {
70056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70057       };
70058     }
70059   }
70060   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70061   return jresult;
70062 }
70063
70064
70065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
70066   void * jresult ;
70067   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70068   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70069
70070   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70071   {
70072     try {
70073       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
70074     } catch (std::out_of_range& e) {
70075       {
70076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70077       };
70078     } catch (std::exception& e) {
70079       {
70080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70081       };
70082     } catch (...) {
70083       {
70084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70085       };
70086     }
70087   }
70088   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70089   return jresult;
70090 }
70091
70092
70093 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
70094   float jresult ;
70095   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70096   Dali::Toolkit::ItemId arg2 ;
70097   float result;
70098
70099   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70100   arg2 = (Dali::Toolkit::ItemId)jarg2;
70101   {
70102     try {
70103       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
70104     } catch (std::out_of_range& e) {
70105       {
70106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70107       };
70108     } catch (std::exception& e) {
70109       {
70110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70111       };
70112     } catch (...) {
70113       {
70114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70115       };
70116     }
70117   }
70118   jresult = result;
70119   return jresult;
70120 }
70121
70122
70123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
70124   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70125   unsigned int arg2 ;
70126   Dali::Vector3 arg3 ;
70127   float arg4 ;
70128   Dali::Vector3 *argp3 ;
70129
70130   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70131   arg2 = (unsigned int)jarg2;
70132   argp3 = (Dali::Vector3 *)jarg3;
70133   if (!argp3) {
70134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70135     return ;
70136   }
70137   arg3 = *argp3;
70138   arg4 = (float)jarg4;
70139   {
70140     try {
70141       (arg1)->ActivateLayout(arg2,arg3,arg4);
70142     } catch (std::out_of_range& e) {
70143       {
70144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70145       };
70146     } catch (std::exception& e) {
70147       {
70148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70149       };
70150     } catch (...) {
70151       {
70152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70153       };
70154     }
70155   }
70156 }
70157
70158
70159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
70160   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70161
70162   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70163   {
70164     try {
70165       (arg1)->DeactivateCurrentLayout();
70166     } catch (std::out_of_range& e) {
70167       {
70168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70169       };
70170     } catch (std::exception& e) {
70171       {
70172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70173       };
70174     } catch (...) {
70175       {
70176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70177       };
70178     }
70179   }
70180 }
70181
70182
70183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
70184   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70185   float arg2 ;
70186
70187   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70188   arg2 = (float)jarg2;
70189   {
70190     try {
70191       (arg1)->SetMinimumSwipeSpeed(arg2);
70192     } catch (std::out_of_range& e) {
70193       {
70194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70195       };
70196     } catch (std::exception& e) {
70197       {
70198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70199       };
70200     } catch (...) {
70201       {
70202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70203       };
70204     }
70205   }
70206 }
70207
70208
70209 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
70210   float jresult ;
70211   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70212   float result;
70213
70214   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70215   {
70216     try {
70217       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
70218     } catch (std::out_of_range& e) {
70219       {
70220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70221       };
70222     } catch (std::exception& e) {
70223       {
70224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70225       };
70226     } catch (...) {
70227       {
70228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70229       };
70230     }
70231   }
70232   jresult = result;
70233   return jresult;
70234 }
70235
70236
70237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
70238   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70239   float arg2 ;
70240
70241   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70242   arg2 = (float)jarg2;
70243   {
70244     try {
70245       (arg1)->SetMinimumSwipeDistance(arg2);
70246     } catch (std::out_of_range& e) {
70247       {
70248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70249       };
70250     } catch (std::exception& e) {
70251       {
70252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70253       };
70254     } catch (...) {
70255       {
70256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70257       };
70258     }
70259   }
70260 }
70261
70262
70263 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
70264   float jresult ;
70265   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70266   float result;
70267
70268   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70269   {
70270     try {
70271       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
70272     } catch (std::out_of_range& e) {
70273       {
70274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70275       };
70276     } catch (std::exception& e) {
70277       {
70278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70279       };
70280     } catch (...) {
70281       {
70282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70283       };
70284     }
70285   }
70286   jresult = result;
70287   return jresult;
70288 }
70289
70290
70291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
70292   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70293   float arg2 ;
70294
70295   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70296   arg2 = (float)jarg2;
70297   {
70298     try {
70299       (arg1)->SetWheelScrollDistanceStep(arg2);
70300     } catch (std::out_of_range& e) {
70301       {
70302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70303       };
70304     } catch (std::exception& e) {
70305       {
70306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70307       };
70308     } catch (...) {
70309       {
70310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70311       };
70312     }
70313   }
70314 }
70315
70316
70317 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
70318   float jresult ;
70319   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70320   float result;
70321
70322   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70323   {
70324     try {
70325       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
70326     } catch (std::out_of_range& e) {
70327       {
70328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70329       };
70330     } catch (std::exception& e) {
70331       {
70332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70333       };
70334     } catch (...) {
70335       {
70336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70337       };
70338     }
70339   }
70340   jresult = result;
70341   return jresult;
70342 }
70343
70344
70345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
70346   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70347   bool arg2 ;
70348
70349   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70350   arg2 = jarg2 ? true : false;
70351   {
70352     try {
70353       (arg1)->SetAnchoring(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 unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
70372   unsigned int jresult ;
70373   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70374   bool result;
70375
70376   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70377   {
70378     try {
70379       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
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_SetAnchoringDuration(void * jarg1, float jarg2) {
70400   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70401   float arg2 ;
70402
70403   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70404   arg2 = (float)jarg2;
70405   {
70406     try {
70407       (arg1)->SetAnchoringDuration(arg2);
70408     } catch (std::out_of_range& e) {
70409       {
70410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70411       };
70412     } catch (std::exception& e) {
70413       {
70414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70415       };
70416     } catch (...) {
70417       {
70418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70419       };
70420     }
70421   }
70422 }
70423
70424
70425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
70426   float jresult ;
70427   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70428   float result;
70429
70430   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70431   {
70432     try {
70433       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
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 = result;
70449   return jresult;
70450 }
70451
70452
70453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
70454   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70455   Dali::Toolkit::ItemId arg2 ;
70456   float arg3 ;
70457
70458   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70459   arg2 = (Dali::Toolkit::ItemId)jarg2;
70460   arg3 = (float)jarg3;
70461   {
70462     try {
70463       (arg1)->ScrollToItem(arg2,arg3);
70464     } catch (std::out_of_range& e) {
70465       {
70466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70467       };
70468     } catch (std::exception& e) {
70469       {
70470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70471       };
70472     } catch (...) {
70473       {
70474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70475       };
70476     }
70477   }
70478 }
70479
70480
70481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
70482   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70483   float arg2 ;
70484
70485   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70486   arg2 = (float)jarg2;
70487   {
70488     try {
70489       (arg1)->SetRefreshInterval(arg2);
70490     } catch (std::out_of_range& e) {
70491       {
70492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70493       };
70494     } catch (std::exception& e) {
70495       {
70496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70497       };
70498     } catch (...) {
70499       {
70500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70501       };
70502     }
70503   }
70504 }
70505
70506
70507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
70508   float jresult ;
70509   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70510   float result;
70511
70512   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70513   {
70514     try {
70515       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
70516     } catch (std::out_of_range& e) {
70517       {
70518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70519       };
70520     } catch (std::exception& e) {
70521       {
70522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70523       };
70524     } catch (...) {
70525       {
70526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70527       };
70528     }
70529   }
70530   jresult = result;
70531   return jresult;
70532 }
70533
70534
70535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
70536   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70537
70538   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70539   {
70540     try {
70541       (arg1)->Refresh();
70542     } catch (std::out_of_range& e) {
70543       {
70544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70545       };
70546     } catch (std::exception& e) {
70547       {
70548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70549       };
70550     } catch (...) {
70551       {
70552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70553       };
70554     }
70555   }
70556 }
70557
70558
70559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
70560   void * jresult ;
70561   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70562   Dali::Toolkit::ItemId arg2 ;
70563   Dali::Actor result;
70564
70565   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70566   arg2 = (Dali::Toolkit::ItemId)jarg2;
70567   {
70568     try {
70569       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
70570     } catch (std::out_of_range& e) {
70571       {
70572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70573       };
70574     } catch (std::exception& e) {
70575       {
70576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70577       };
70578     } catch (...) {
70579       {
70580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70581       };
70582     }
70583   }
70584   jresult = new Dali::Actor((const Dali::Actor &)result);
70585   return jresult;
70586 }
70587
70588
70589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
70590   unsigned int jresult ;
70591   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70592   Dali::Actor arg2 ;
70593   Dali::Actor *argp2 ;
70594   Dali::Toolkit::ItemId result;
70595
70596   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70597   argp2 = (Dali::Actor *)jarg2;
70598   if (!argp2) {
70599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70600     return 0;
70601   }
70602   arg2 = *argp2;
70603   {
70604     try {
70605       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
70606     } catch (std::out_of_range& e) {
70607       {
70608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70609       };
70610     } catch (std::exception& e) {
70611       {
70612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70613       };
70614     } catch (...) {
70615       {
70616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70617       };
70618     }
70619   }
70620   jresult = result;
70621   return jresult;
70622 }
70623
70624
70625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
70626   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70627   Dali::Toolkit::Item arg2 ;
70628   float arg3 ;
70629   Dali::Toolkit::Item *argp2 ;
70630
70631   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70632   argp2 = (Dali::Toolkit::Item *)jarg2;
70633   if (!argp2) {
70634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70635     return ;
70636   }
70637   arg2 = *argp2;
70638   arg3 = (float)jarg3;
70639   {
70640     try {
70641       (arg1)->InsertItem(arg2,arg3);
70642     } catch (std::out_of_range& e) {
70643       {
70644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70645       };
70646     } catch (std::exception& e) {
70647       {
70648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70649       };
70650     } catch (...) {
70651       {
70652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70653       };
70654     }
70655   }
70656 }
70657
70658
70659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
70660   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70661   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70662   float arg3 ;
70663
70664   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70665   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70666   if (!arg2) {
70667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70668     return ;
70669   }
70670   arg3 = (float)jarg3;
70671   {
70672     try {
70673       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70674     } catch (std::out_of_range& e) {
70675       {
70676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70677       };
70678     } catch (std::exception& e) {
70679       {
70680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70681       };
70682     } catch (...) {
70683       {
70684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70685       };
70686     }
70687   }
70688 }
70689
70690
70691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
70692   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70693   Dali::Toolkit::ItemId arg2 ;
70694   float arg3 ;
70695
70696   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70697   arg2 = (Dali::Toolkit::ItemId)jarg2;
70698   arg3 = (float)jarg3;
70699   {
70700     try {
70701       (arg1)->RemoveItem(arg2,arg3);
70702     } catch (std::out_of_range& e) {
70703       {
70704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70705       };
70706     } catch (std::exception& e) {
70707       {
70708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70709       };
70710     } catch (...) {
70711       {
70712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70713       };
70714     }
70715   }
70716 }
70717
70718
70719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
70720   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70721   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
70722   float arg3 ;
70723
70724   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70725   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
70726   if (!arg2) {
70727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
70728     return ;
70729   }
70730   arg3 = (float)jarg3;
70731   {
70732     try {
70733       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
70734     } catch (std::out_of_range& e) {
70735       {
70736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70737       };
70738     } catch (std::exception& e) {
70739       {
70740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70741       };
70742     } catch (...) {
70743       {
70744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70745       };
70746     }
70747   }
70748 }
70749
70750
70751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
70752   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70753   Dali::Toolkit::Item arg2 ;
70754   float arg3 ;
70755   Dali::Toolkit::Item *argp2 ;
70756
70757   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70758   argp2 = (Dali::Toolkit::Item *)jarg2;
70759   if (!argp2) {
70760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70761     return ;
70762   }
70763   arg2 = *argp2;
70764   arg3 = (float)jarg3;
70765   {
70766     try {
70767       (arg1)->ReplaceItem(arg2,arg3);
70768     } catch (std::out_of_range& e) {
70769       {
70770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70771       };
70772     } catch (std::exception& e) {
70773       {
70774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70775       };
70776     } catch (...) {
70777       {
70778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70779       };
70780     }
70781   }
70782 }
70783
70784
70785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
70786   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70787   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70788   float arg3 ;
70789
70790   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70791   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70792   if (!arg2) {
70793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70794     return ;
70795   }
70796   arg3 = (float)jarg3;
70797   {
70798     try {
70799       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70800     } catch (std::out_of_range& e) {
70801       {
70802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70803       };
70804     } catch (std::exception& e) {
70805       {
70806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70807       };
70808     } catch (...) {
70809       {
70810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70811       };
70812     }
70813   }
70814 }
70815
70816
70817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
70818   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70819   Dali::Vector3 *arg2 = 0 ;
70820
70821   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70822   arg2 = (Dali::Vector3 *)jarg2;
70823   if (!arg2) {
70824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70825     return ;
70826   }
70827   {
70828     try {
70829       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
70830     } catch (std::out_of_range& e) {
70831       {
70832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70833       };
70834     } catch (std::exception& e) {
70835       {
70836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70837       };
70838     } catch (...) {
70839       {
70840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70841       };
70842     }
70843   }
70844 }
70845
70846
70847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
70848   void * jresult ;
70849   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70850   Dali::Vector3 result;
70851
70852   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70853   {
70854     try {
70855       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
70856     } catch (std::out_of_range& e) {
70857       {
70858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70859       };
70860     } catch (std::exception& e) {
70861       {
70862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70863       };
70864     } catch (...) {
70865       {
70866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70867       };
70868     }
70869   }
70870   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70871   return jresult;
70872 }
70873
70874
70875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
70876   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70877   Dali::Vector3 *arg2 = 0 ;
70878
70879   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70880   arg2 = (Dali::Vector3 *)jarg2;
70881   if (!arg2) {
70882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70883     return ;
70884   }
70885   {
70886     try {
70887       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
70888     } catch (std::out_of_range& e) {
70889       {
70890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70891       };
70892     } catch (std::exception& e) {
70893       {
70894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70895       };
70896     } catch (...) {
70897       {
70898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70899       };
70900     }
70901   }
70902 }
70903
70904
70905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
70906   void * jresult ;
70907   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70908   Dali::Vector3 result;
70909
70910   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70911   {
70912     try {
70913       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
70914     } catch (std::out_of_range& e) {
70915       {
70916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70917       };
70918     } catch (std::exception& e) {
70919       {
70920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70921       };
70922     } catch (...) {
70923       {
70924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70925       };
70926     }
70927   }
70928   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70929   return jresult;
70930 }
70931
70932
70933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
70934   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70935   Dali::Toolkit::ItemRange *arg2 = 0 ;
70936
70937   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70938   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
70939   if (!arg2) {
70940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
70941     return ;
70942   }
70943   {
70944     try {
70945       (arg1)->GetItemsRange(*arg2);
70946     } catch (std::out_of_range& e) {
70947       {
70948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70949       };
70950     } catch (std::exception& e) {
70951       {
70952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70953       };
70954     } catch (...) {
70955       {
70956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70957       };
70958     }
70959   }
70960 }
70961
70962
70963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
70964   void * jresult ;
70965   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70966   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
70967
70968   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70969   {
70970     try {
70971       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
70972     } catch (std::out_of_range& e) {
70973       {
70974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70975       };
70976     } catch (std::exception& e) {
70977       {
70978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70979       };
70980     } catch (...) {
70981       {
70982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70983       };
70984     }
70985   }
70986   jresult = (void *)result;
70987   return jresult;
70988 }
70989
70990
70991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
70992   Dali::Vector3 *arg1 = 0 ;
70993   PropertyInputContainer *arg2 = 0 ;
70994
70995   arg1 = (Dali::Vector3 *)jarg1;
70996   if (!arg1) {
70997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70998     return ;
70999   }
71000   arg2 = (PropertyInputContainer *)jarg2;
71001   if (!arg2) {
71002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71003     return ;
71004   }
71005   {
71006     try {
71007       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71008     } catch (std::out_of_range& e) {
71009       {
71010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71011       };
71012     } catch (std::exception& e) {
71013       {
71014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71015       };
71016     } catch (...) {
71017       {
71018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71019       };
71020     }
71021   }
71022 }
71023
71024
71025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
71026   Dali::Vector3 *arg1 = 0 ;
71027   PropertyInputContainer *arg2 = 0 ;
71028
71029   arg1 = (Dali::Vector3 *)jarg1;
71030   if (!arg1) {
71031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71032     return ;
71033   }
71034   arg2 = (PropertyInputContainer *)jarg2;
71035   if (!arg2) {
71036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71037     return ;
71038   }
71039   {
71040     try {
71041       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71042     } catch (std::out_of_range& e) {
71043       {
71044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71045       };
71046     } catch (std::exception& e) {
71047       {
71048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71049       };
71050     } catch (...) {
71051       {
71052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71053       };
71054     }
71055   }
71056 }
71057
71058
71059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
71060   void * jresult ;
71061   Dali::Toolkit::ScrollViewEffect *result = 0 ;
71062
71063   {
71064     try {
71065       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
71066     } catch (std::out_of_range& e) {
71067       {
71068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71069       };
71070     } catch (std::exception& e) {
71071       {
71072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71073       };
71074     } catch (...) {
71075       {
71076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71077       };
71078     }
71079   }
71080   jresult = (void *)result;
71081   return jresult;
71082 }
71083
71084
71085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
71086   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
71087
71088   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
71089   {
71090     try {
71091       delete arg1;
71092     } catch (std::out_of_range& e) {
71093       {
71094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71095       };
71096     } catch (std::exception& e) {
71097       {
71098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71099       };
71100     } catch (...) {
71101       {
71102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71103       };
71104     }
71105   }
71106 }
71107
71108
71109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
71110   void * jresult ;
71111   Dali::Path arg1 ;
71112   Dali::Vector3 *arg2 = 0 ;
71113   Dali::Property::Index arg3 ;
71114   Dali::Vector3 *arg4 = 0 ;
71115   unsigned int arg5 ;
71116   Dali::Path *argp1 ;
71117   Dali::Toolkit::ScrollViewPagePathEffect result;
71118
71119   argp1 = (Dali::Path *)jarg1;
71120   if (!argp1) {
71121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
71122     return 0;
71123   }
71124   arg1 = *argp1;
71125   arg2 = (Dali::Vector3 *)jarg2;
71126   if (!arg2) {
71127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71128     return 0;
71129   }
71130   arg3 = (Dali::Property::Index)jarg3;
71131   arg4 = (Dali::Vector3 *)jarg4;
71132   if (!arg4) {
71133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71134     return 0;
71135   }
71136   arg5 = (unsigned int)jarg5;
71137   {
71138     try {
71139       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
71140     } catch (std::out_of_range& e) {
71141       {
71142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71143       };
71144     } catch (std::exception& e) {
71145       {
71146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71147       };
71148     } catch (...) {
71149       {
71150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71151       };
71152     }
71153   }
71154   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71155   return jresult;
71156 }
71157
71158
71159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
71160   void * jresult ;
71161   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
71162
71163   {
71164     try {
71165       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
71166     } catch (std::out_of_range& e) {
71167       {
71168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71169       };
71170     } catch (std::exception& e) {
71171       {
71172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71173       };
71174     } catch (...) {
71175       {
71176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71177       };
71178     }
71179   }
71180   jresult = (void *)result;
71181   return jresult;
71182 }
71183
71184
71185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
71186   void * jresult ;
71187   Dali::BaseHandle arg1 ;
71188   Dali::BaseHandle *argp1 ;
71189   Dali::Toolkit::ScrollViewPagePathEffect result;
71190
71191   argp1 = (Dali::BaseHandle *)jarg1;
71192   if (!argp1) {
71193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71194     return 0;
71195   }
71196   arg1 = *argp1;
71197   {
71198     try {
71199       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
71200     } catch (std::out_of_range& e) {
71201       {
71202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71203       };
71204     } catch (std::exception& e) {
71205       {
71206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71207       };
71208     } catch (...) {
71209       {
71210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71211       };
71212     }
71213   }
71214   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71215   return jresult;
71216 }
71217
71218
71219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
71220   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71221   Dali::Actor arg2 ;
71222   unsigned int arg3 ;
71223   Dali::Actor *argp2 ;
71224
71225   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71226   argp2 = (Dali::Actor *)jarg2;
71227   if (!argp2) {
71228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71229     return ;
71230   }
71231   arg2 = *argp2;
71232   arg3 = (unsigned int)jarg3;
71233   {
71234     try {
71235       (arg1)->ApplyToPage(arg2,arg3);
71236     } catch (std::out_of_range& e) {
71237       {
71238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71239       };
71240     } catch (std::exception& e) {
71241       {
71242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71243       };
71244     } catch (...) {
71245       {
71246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71247       };
71248     }
71249   }
71250 }
71251
71252
71253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
71254   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71255
71256   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71257   {
71258     try {
71259       delete arg1;
71260     } catch (std::out_of_range& e) {
71261       {
71262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71263       };
71264     } catch (std::exception& e) {
71265       {
71266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71267       };
71268     } catch (...) {
71269       {
71270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71271       };
71272     }
71273   }
71274 }
71275
71276
71277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
71278   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71279   Dali::Toolkit::ClampState arg2 ;
71280
71281   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71282   arg2 = (Dali::Toolkit::ClampState)jarg2;
71283   if (arg1) (arg1)->x = arg2;
71284 }
71285
71286
71287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
71288   int jresult ;
71289   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71290   Dali::Toolkit::ClampState result;
71291
71292   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71293   result = (Dali::Toolkit::ClampState) ((arg1)->x);
71294   jresult = (int)result;
71295   return jresult;
71296 }
71297
71298
71299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
71300   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71301   Dali::Toolkit::ClampState arg2 ;
71302
71303   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71304   arg2 = (Dali::Toolkit::ClampState)jarg2;
71305   if (arg1) (arg1)->y = arg2;
71306 }
71307
71308
71309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
71310   int jresult ;
71311   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71312   Dali::Toolkit::ClampState result;
71313
71314   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71315   result = (Dali::Toolkit::ClampState) ((arg1)->y);
71316   jresult = (int)result;
71317   return jresult;
71318 }
71319
71320
71321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
71322   void * jresult ;
71323   Dali::Toolkit::ClampState2D *result = 0 ;
71324
71325   {
71326     try {
71327       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
71328     } catch (std::out_of_range& e) {
71329       {
71330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71331       };
71332     } catch (std::exception& e) {
71333       {
71334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71335       };
71336     } catch (...) {
71337       {
71338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71339       };
71340     }
71341   }
71342   jresult = (void *)result;
71343   return jresult;
71344 }
71345
71346
71347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
71348   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71349
71350   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71351   {
71352     try {
71353       delete arg1;
71354     } catch (std::out_of_range& e) {
71355       {
71356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71357       };
71358     } catch (std::exception& e) {
71359       {
71360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71361       };
71362     } catch (...) {
71363       {
71364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71365       };
71366     }
71367   }
71368 }
71369
71370
71371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
71372   void * jresult ;
71373   float arg1 ;
71374   float arg2 ;
71375   bool arg3 ;
71376   Dali::Toolkit::RulerDomain *result = 0 ;
71377
71378   arg1 = (float)jarg1;
71379   arg2 = (float)jarg2;
71380   arg3 = jarg3 ? true : false;
71381   {
71382     try {
71383       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
71384     } catch (std::out_of_range& e) {
71385       {
71386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71387       };
71388     } catch (std::exception& e) {
71389       {
71390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71391       };
71392     } catch (...) {
71393       {
71394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71395       };
71396     }
71397   }
71398   jresult = (void *)result;
71399   return jresult;
71400 }
71401
71402
71403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
71404   void * jresult ;
71405   float arg1 ;
71406   float arg2 ;
71407   Dali::Toolkit::RulerDomain *result = 0 ;
71408
71409   arg1 = (float)jarg1;
71410   arg2 = (float)jarg2;
71411   {
71412     try {
71413       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
71414     } catch (std::out_of_range& e) {
71415       {
71416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71417       };
71418     } catch (std::exception& e) {
71419       {
71420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71421       };
71422     } catch (...) {
71423       {
71424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71425       };
71426     }
71427   }
71428   jresult = (void *)result;
71429   return jresult;
71430 }
71431
71432
71433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
71434   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71435   float arg2 ;
71436
71437   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71438   arg2 = (float)jarg2;
71439   if (arg1) (arg1)->min = arg2;
71440 }
71441
71442
71443 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
71444   float jresult ;
71445   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71446   float result;
71447
71448   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71449   result = (float) ((arg1)->min);
71450   jresult = result;
71451   return jresult;
71452 }
71453
71454
71455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
71456   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71457   float arg2 ;
71458
71459   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71460   arg2 = (float)jarg2;
71461   if (arg1) (arg1)->max = arg2;
71462 }
71463
71464
71465 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
71466   float jresult ;
71467   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71468   float result;
71469
71470   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71471   result = (float) ((arg1)->max);
71472   jresult = result;
71473   return jresult;
71474 }
71475
71476
71477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
71478   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71479   bool arg2 ;
71480
71481   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71482   arg2 = jarg2 ? true : false;
71483   if (arg1) (arg1)->enabled = arg2;
71484 }
71485
71486
71487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
71488   unsigned int jresult ;
71489   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71490   bool result;
71491
71492   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71493   result = (bool) ((arg1)->enabled);
71494   jresult = result;
71495   return jresult;
71496 }
71497
71498
71499 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
71500   float jresult ;
71501   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71502   float arg2 ;
71503   float arg3 ;
71504   float arg4 ;
71505   float result;
71506
71507   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71508   arg2 = (float)jarg2;
71509   arg3 = (float)jarg3;
71510   arg4 = (float)jarg4;
71511   {
71512     try {
71513       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
71514     } catch (std::out_of_range& e) {
71515       {
71516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71517       };
71518     } catch (std::exception& e) {
71519       {
71520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71521       };
71522     } catch (...) {
71523       {
71524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71525       };
71526     }
71527   }
71528   jresult = result;
71529   return jresult;
71530 }
71531
71532
71533 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
71534   float jresult ;
71535   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71536   float arg2 ;
71537   float arg3 ;
71538   float result;
71539
71540   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71541   arg2 = (float)jarg2;
71542   arg3 = (float)jarg3;
71543   {
71544     try {
71545       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
71546     } catch (std::out_of_range& e) {
71547       {
71548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71549       };
71550     } catch (std::exception& e) {
71551       {
71552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71553       };
71554     } catch (...) {
71555       {
71556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71557       };
71558     }
71559   }
71560   jresult = result;
71561   return jresult;
71562 }
71563
71564
71565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
71566   float jresult ;
71567   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71568   float arg2 ;
71569   float result;
71570
71571   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71572   arg2 = (float)jarg2;
71573   {
71574     try {
71575       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
71576     } catch (std::out_of_range& e) {
71577       {
71578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71579       };
71580     } catch (std::exception& e) {
71581       {
71582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71583       };
71584     } catch (...) {
71585       {
71586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71587       };
71588     }
71589   }
71590   jresult = result;
71591   return jresult;
71592 }
71593
71594
71595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
71596   float jresult ;
71597   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71598   float arg2 ;
71599   float arg3 ;
71600   float arg4 ;
71601   Dali::Toolkit::ClampState *arg5 = 0 ;
71602   float result;
71603
71604   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71605   arg2 = (float)jarg2;
71606   arg3 = (float)jarg3;
71607   arg4 = (float)jarg4;
71608   arg5 = (Dali::Toolkit::ClampState *)jarg5;
71609   if (!arg5) {
71610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
71611     return 0;
71612   }
71613   {
71614     try {
71615       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
71616     } catch (std::out_of_range& e) {
71617       {
71618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71619       };
71620     } catch (std::exception& e) {
71621       {
71622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71623       };
71624     } catch (...) {
71625       {
71626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71627       };
71628     }
71629   }
71630   jresult = result;
71631   return jresult;
71632 }
71633
71634
71635 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
71636   float jresult ;
71637   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71638   float result;
71639
71640   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71641   {
71642     try {
71643       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
71644     } catch (std::out_of_range& e) {
71645       {
71646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71647       };
71648     } catch (std::exception& e) {
71649       {
71650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71651       };
71652     } catch (...) {
71653       {
71654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71655       };
71656     }
71657   }
71658   jresult = result;
71659   return jresult;
71660 }
71661
71662
71663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
71664   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71665
71666   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71667   {
71668     try {
71669       delete arg1;
71670     } catch (std::out_of_range& e) {
71671       {
71672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71673       };
71674     } catch (std::exception& e) {
71675       {
71676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71677       };
71678     } catch (...) {
71679       {
71680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71681       };
71682     }
71683   }
71684 }
71685
71686
71687 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
71688   float jresult ;
71689   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71690   float arg2 ;
71691   float arg3 ;
71692   float result;
71693
71694   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71695   arg2 = (float)jarg2;
71696   arg3 = (float)jarg3;
71697   {
71698     try {
71699       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
71700     } catch (std::out_of_range& e) {
71701       {
71702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71703       };
71704     } catch (std::exception& e) {
71705       {
71706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71707       };
71708     } catch (...) {
71709       {
71710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71711       };
71712     }
71713   }
71714   jresult = result;
71715   return jresult;
71716 }
71717
71718
71719 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
71720   float jresult ;
71721   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71722   float arg2 ;
71723   float result;
71724
71725   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71726   arg2 = (float)jarg2;
71727   {
71728     try {
71729       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
71730     } catch (std::out_of_range& e) {
71731       {
71732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71733       };
71734     } catch (std::exception& e) {
71735       {
71736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71737       };
71738     } catch (...) {
71739       {
71740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71741       };
71742     }
71743   }
71744   jresult = result;
71745   return jresult;
71746 }
71747
71748
71749 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
71750   float jresult ;
71751   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71752   unsigned int arg2 ;
71753   unsigned int *arg3 = 0 ;
71754   bool arg4 ;
71755   float result;
71756
71757   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71758   arg2 = (unsigned int)jarg2;
71759   arg3 = (unsigned int *)jarg3;
71760   arg4 = jarg4 ? true : false;
71761   {
71762     try {
71763       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
71764     } catch (std::out_of_range& e) {
71765       {
71766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71767       };
71768     } catch (std::exception& e) {
71769       {
71770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71771       };
71772     } catch (...) {
71773       {
71774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71775       };
71776     }
71777   }
71778   jresult = result;
71779   return jresult;
71780 }
71781
71782
71783 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
71784   unsigned int jresult ;
71785   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71786   float arg2 ;
71787   bool arg3 ;
71788   unsigned int result;
71789
71790   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71791   arg2 = (float)jarg2;
71792   arg3 = jarg3 ? true : false;
71793   {
71794     try {
71795       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
71796     } catch (std::out_of_range& e) {
71797       {
71798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71799       };
71800     } catch (std::exception& e) {
71801       {
71802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71803       };
71804     } catch (...) {
71805       {
71806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71807       };
71808     }
71809   }
71810   jresult = result;
71811   return jresult;
71812 }
71813
71814
71815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
71816   unsigned int jresult ;
71817   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71818   unsigned int result;
71819
71820   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71821   {
71822     try {
71823       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
71824     } catch (std::out_of_range& e) {
71825       {
71826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71827       };
71828     } catch (std::exception& e) {
71829       {
71830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71831       };
71832     } catch (...) {
71833       {
71834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71835       };
71836     }
71837   }
71838   jresult = result;
71839   return jresult;
71840 }
71841
71842
71843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
71844   int jresult ;
71845   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71846   Dali::Toolkit::Ruler::RulerType result;
71847
71848   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71849   {
71850     try {
71851       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
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 = (int)result;
71867   return jresult;
71868 }
71869
71870
71871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
71872   unsigned int jresult ;
71873   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71874   bool result;
71875
71876   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71877   {
71878     try {
71879       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
71880     } catch (std::out_of_range& e) {
71881       {
71882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71883       };
71884     } catch (std::exception& e) {
71885       {
71886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71887       };
71888     } catch (...) {
71889       {
71890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71891       };
71892     }
71893   }
71894   jresult = result;
71895   return jresult;
71896 }
71897
71898
71899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
71900   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71901
71902   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71903   {
71904     try {
71905       (arg1)->Enable();
71906     } catch (std::out_of_range& e) {
71907       {
71908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71909       };
71910     } catch (std::exception& e) {
71911       {
71912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71913       };
71914     } catch (...) {
71915       {
71916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71917       };
71918     }
71919   }
71920 }
71921
71922
71923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
71924   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71925
71926   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71927   {
71928     try {
71929       (arg1)->Disable();
71930     } catch (std::out_of_range& e) {
71931       {
71932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71933       };
71934     } catch (std::exception& e) {
71935       {
71936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71937       };
71938     } catch (...) {
71939       {
71940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71941       };
71942     }
71943   }
71944 }
71945
71946
71947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
71948   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71949   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
71950   Dali::Toolkit::RulerDomain *argp2 ;
71951
71952   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71953   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
71954   if (!argp2) {
71955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
71956     return ;
71957   }
71958   arg2 = *argp2;
71959   {
71960     try {
71961       (arg1)->SetDomain(arg2);
71962     } catch (std::out_of_range& e) {
71963       {
71964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71965       };
71966     } catch (std::exception& e) {
71967       {
71968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71969       };
71970     } catch (...) {
71971       {
71972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71973       };
71974     }
71975   }
71976 }
71977
71978
71979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
71980   void * jresult ;
71981   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71982   Dali::Toolkit::RulerDomain *result = 0 ;
71983
71984   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71985   {
71986     try {
71987       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
71988     } catch (std::out_of_range& e) {
71989       {
71990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71991       };
71992     } catch (std::exception& e) {
71993       {
71994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71995       };
71996     } catch (...) {
71997       {
71998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71999       };
72000     }
72001   }
72002   jresult = (void *)result;
72003   return jresult;
72004 }
72005
72006
72007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
72008   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72009
72010   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72011   {
72012     try {
72013       (arg1)->DisableDomain();
72014     } catch (std::out_of_range& e) {
72015       {
72016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72017       };
72018     } catch (std::exception& e) {
72019       {
72020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72021       };
72022     } catch (...) {
72023       {
72024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72025       };
72026     }
72027   }
72028 }
72029
72030
72031 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72032   float jresult ;
72033   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72034   float arg2 ;
72035   float arg3 ;
72036   float arg4 ;
72037   float result;
72038
72039   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72040   arg2 = (float)jarg2;
72041   arg3 = (float)jarg3;
72042   arg4 = (float)jarg4;
72043   {
72044     try {
72045       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
72046     } catch (std::out_of_range& e) {
72047       {
72048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72049       };
72050     } catch (std::exception& e) {
72051       {
72052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72053       };
72054     } catch (...) {
72055       {
72056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72057       };
72058     }
72059   }
72060   jresult = result;
72061   return jresult;
72062 }
72063
72064
72065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72066   float jresult ;
72067   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72068   float arg2 ;
72069   float arg3 ;
72070   float result;
72071
72072   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72073   arg2 = (float)jarg2;
72074   arg3 = (float)jarg3;
72075   {
72076     try {
72077       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
72078     } catch (std::out_of_range& e) {
72079       {
72080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72081       };
72082     } catch (std::exception& e) {
72083       {
72084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72085       };
72086     } catch (...) {
72087       {
72088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72089       };
72090     }
72091   }
72092   jresult = result;
72093   return jresult;
72094 }
72095
72096
72097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
72098   float jresult ;
72099   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72100   float arg2 ;
72101   float result;
72102
72103   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72104   arg2 = (float)jarg2;
72105   {
72106     try {
72107       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
72108     } catch (std::out_of_range& e) {
72109       {
72110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72111       };
72112     } catch (std::exception& e) {
72113       {
72114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72115       };
72116     } catch (...) {
72117       {
72118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72119       };
72120     }
72121   }
72122   jresult = result;
72123   return jresult;
72124 }
72125
72126
72127 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72128   float jresult ;
72129   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72130   float arg2 ;
72131   float arg3 ;
72132   float arg4 ;
72133   Dali::Toolkit::ClampState *arg5 = 0 ;
72134   float result;
72135
72136   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72137   arg2 = (float)jarg2;
72138   arg3 = (float)jarg3;
72139   arg4 = (float)jarg4;
72140   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72141   if (!arg5) {
72142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72143     return 0;
72144   }
72145   {
72146     try {
72147       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72148     } catch (std::out_of_range& e) {
72149       {
72150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72151       };
72152     } catch (std::exception& e) {
72153       {
72154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72155       };
72156     } catch (...) {
72157       {
72158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72159       };
72160     }
72161   }
72162   jresult = result;
72163   return jresult;
72164 }
72165
72166
72167 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
72168   float jresult ;
72169   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72170   float arg2 ;
72171   float arg3 ;
72172   float arg4 ;
72173   float arg5 ;
72174   float result;
72175
72176   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72177   arg2 = (float)jarg2;
72178   arg3 = (float)jarg3;
72179   arg4 = (float)jarg4;
72180   arg5 = (float)jarg5;
72181   {
72182     try {
72183       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
72184     } catch (std::out_of_range& e) {
72185       {
72186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72187       };
72188     } catch (std::exception& e) {
72189       {
72190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72191       };
72192     } catch (...) {
72193       {
72194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72195       };
72196     }
72197   }
72198   jresult = result;
72199   return jresult;
72200 }
72201
72202
72203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
72204   float jresult ;
72205   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72206   float arg2 ;
72207   float arg3 ;
72208   float arg4 ;
72209   float result;
72210
72211   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72212   arg2 = (float)jarg2;
72213   arg3 = (float)jarg3;
72214   arg4 = (float)jarg4;
72215   {
72216     try {
72217       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
72218     } catch (std::out_of_range& e) {
72219       {
72220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72221       };
72222     } catch (std::exception& e) {
72223       {
72224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72225       };
72226     } catch (...) {
72227       {
72228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72229       };
72230     }
72231   }
72232   jresult = result;
72233   return jresult;
72234 }
72235
72236
72237 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
72238   float jresult ;
72239   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72240   float arg2 ;
72241   float arg3 ;
72242   float result;
72243
72244   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72245   arg2 = (float)jarg2;
72246   arg3 = (float)jarg3;
72247   {
72248     try {
72249       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
72250     } catch (std::out_of_range& e) {
72251       {
72252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72253       };
72254     } catch (std::exception& e) {
72255       {
72256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72257       };
72258     } catch (...) {
72259       {
72260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72261       };
72262     }
72263   }
72264   jresult = result;
72265   return jresult;
72266 }
72267
72268
72269 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
72270   float jresult ;
72271   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72272   float arg2 ;
72273   float result;
72274
72275   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72276   arg2 = (float)jarg2;
72277   {
72278     try {
72279       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
72280     } catch (std::out_of_range& e) {
72281       {
72282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72283       };
72284     } catch (std::exception& e) {
72285       {
72286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72287       };
72288     } catch (...) {
72289       {
72290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72291       };
72292     }
72293   }
72294   jresult = result;
72295   return jresult;
72296 }
72297
72298
72299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
72300   float jresult ;
72301   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72302   float arg2 ;
72303   float arg3 ;
72304   float arg4 ;
72305   float arg5 ;
72306   Dali::Toolkit::ClampState *arg6 = 0 ;
72307   float result;
72308
72309   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72310   arg2 = (float)jarg2;
72311   arg3 = (float)jarg3;
72312   arg4 = (float)jarg4;
72313   arg5 = (float)jarg5;
72314   arg6 = (Dali::Toolkit::ClampState *)jarg6;
72315   if (!arg6) {
72316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72317     return 0;
72318   }
72319   {
72320     try {
72321       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
72322     } catch (std::out_of_range& e) {
72323       {
72324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72325       };
72326     } catch (std::exception& e) {
72327       {
72328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72329       };
72330     } catch (...) {
72331       {
72332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72333       };
72334     }
72335   }
72336   jresult = result;
72337   return jresult;
72338 }
72339
72340
72341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
72342   void * jresult ;
72343   Dali::Toolkit::DefaultRuler *result = 0 ;
72344
72345   {
72346     try {
72347       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
72348     } catch (std::out_of_range& e) {
72349       {
72350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72351       };
72352     } catch (std::exception& e) {
72353       {
72354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72355       };
72356     } catch (...) {
72357       {
72358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72359       };
72360     }
72361   }
72362   jresult = (void *)result;
72363   return jresult;
72364 }
72365
72366
72367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
72368   float jresult ;
72369   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72370   float arg2 ;
72371   float arg3 ;
72372   float result;
72373
72374   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72375   arg2 = (float)jarg2;
72376   arg3 = (float)jarg3;
72377   {
72378     try {
72379       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
72380     } catch (std::out_of_range& e) {
72381       {
72382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72383       };
72384     } catch (std::exception& e) {
72385       {
72386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72387       };
72388     } catch (...) {
72389       {
72390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72391       };
72392     }
72393   }
72394   jresult = result;
72395   return jresult;
72396 }
72397
72398
72399 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72400   float jresult ;
72401   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72402   unsigned int arg2 ;
72403   unsigned int *arg3 = 0 ;
72404   bool arg4 ;
72405   float result;
72406
72407   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72408   arg2 = (unsigned int)jarg2;
72409   arg3 = (unsigned int *)jarg3;
72410   arg4 = jarg4 ? true : false;
72411   {
72412     try {
72413       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72414     } catch (std::out_of_range& e) {
72415       {
72416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72417       };
72418     } catch (std::exception& e) {
72419       {
72420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72421       };
72422     } catch (...) {
72423       {
72424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72425       };
72426     }
72427   }
72428   jresult = result;
72429   return jresult;
72430 }
72431
72432
72433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72434   unsigned int jresult ;
72435   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72436   float arg2 ;
72437   bool arg3 ;
72438   unsigned int result;
72439
72440   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72441   arg2 = (float)jarg2;
72442   arg3 = jarg3 ? true : false;
72443   {
72444     try {
72445       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
72446     } catch (std::out_of_range& e) {
72447       {
72448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72449       };
72450     } catch (std::exception& e) {
72451       {
72452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72453       };
72454     } catch (...) {
72455       {
72456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72457       };
72458     }
72459   }
72460   jresult = result;
72461   return jresult;
72462 }
72463
72464
72465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
72466   unsigned int jresult ;
72467   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72468   unsigned int result;
72469
72470   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72471   {
72472     try {
72473       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
72474     } catch (std::out_of_range& e) {
72475       {
72476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72477       };
72478     } catch (std::exception& e) {
72479       {
72480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72481       };
72482     } catch (...) {
72483       {
72484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72485       };
72486     }
72487   }
72488   jresult = result;
72489   return jresult;
72490 }
72491
72492
72493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
72494   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72495
72496   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72497   {
72498     try {
72499       delete arg1;
72500     } catch (std::out_of_range& e) {
72501       {
72502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72503       };
72504     } catch (std::exception& e) {
72505       {
72506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72507       };
72508     } catch (...) {
72509       {
72510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72511       };
72512     }
72513   }
72514 }
72515
72516
72517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
72518   void * jresult ;
72519   float arg1 ;
72520   Dali::Toolkit::FixedRuler *result = 0 ;
72521
72522   arg1 = (float)jarg1;
72523   {
72524     try {
72525       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
72526     } catch (std::out_of_range& e) {
72527       {
72528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72529       };
72530     } catch (std::exception& e) {
72531       {
72532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72533       };
72534     } catch (...) {
72535       {
72536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72537       };
72538     }
72539   }
72540   jresult = (void *)result;
72541   return jresult;
72542 }
72543
72544
72545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
72546   void * jresult ;
72547   Dali::Toolkit::FixedRuler *result = 0 ;
72548
72549   {
72550     try {
72551       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
72552     } catch (std::out_of_range& e) {
72553       {
72554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72555       };
72556     } catch (std::exception& e) {
72557       {
72558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72559       };
72560     } catch (...) {
72561       {
72562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72563       };
72564     }
72565   }
72566   jresult = (void *)result;
72567   return jresult;
72568 }
72569
72570
72571 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
72572   float jresult ;
72573   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72574   float arg2 ;
72575   float arg3 ;
72576   float result;
72577
72578   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72579   arg2 = (float)jarg2;
72580   arg3 = (float)jarg3;
72581   {
72582     try {
72583       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
72584     } catch (std::out_of_range& e) {
72585       {
72586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72587       };
72588     } catch (std::exception& e) {
72589       {
72590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72591       };
72592     } catch (...) {
72593       {
72594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72595       };
72596     }
72597   }
72598   jresult = result;
72599   return jresult;
72600 }
72601
72602
72603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72604   float jresult ;
72605   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72606   unsigned int arg2 ;
72607   unsigned int *arg3 = 0 ;
72608   bool arg4 ;
72609   float result;
72610
72611   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72612   arg2 = (unsigned int)jarg2;
72613   arg3 = (unsigned int *)jarg3;
72614   arg4 = jarg4 ? true : false;
72615   {
72616     try {
72617       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72618     } catch (std::out_of_range& e) {
72619       {
72620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72621       };
72622     } catch (std::exception& e) {
72623       {
72624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72625       };
72626     } catch (...) {
72627       {
72628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72629       };
72630     }
72631   }
72632   jresult = result;
72633   return jresult;
72634 }
72635
72636
72637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72638   unsigned int jresult ;
72639   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72640   float arg2 ;
72641   bool arg3 ;
72642   unsigned int result;
72643
72644   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72645   arg2 = (float)jarg2;
72646   arg3 = jarg3 ? true : false;
72647   {
72648     try {
72649       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
72650     } catch (std::out_of_range& e) {
72651       {
72652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72653       };
72654     } catch (std::exception& e) {
72655       {
72656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72657       };
72658     } catch (...) {
72659       {
72660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72661       };
72662     }
72663   }
72664   jresult = result;
72665   return jresult;
72666 }
72667
72668
72669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
72670   unsigned int jresult ;
72671   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72672   unsigned int result;
72673
72674   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72675   {
72676     try {
72677       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
72678     } catch (std::out_of_range& e) {
72679       {
72680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72681       };
72682     } catch (std::exception& e) {
72683       {
72684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72685       };
72686     } catch (...) {
72687       {
72688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72689       };
72690     }
72691   }
72692   jresult = result;
72693   return jresult;
72694 }
72695
72696
72697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
72698   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72699
72700   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72701   {
72702     try {
72703       delete arg1;
72704     } catch (std::out_of_range& e) {
72705       {
72706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72707       };
72708     } catch (std::exception& e) {
72709       {
72710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72711       };
72712     } catch (...) {
72713       {
72714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72715       };
72716     }
72717   }
72718 }
72719
72720
72721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
72722   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72723   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72724
72725   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72726   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72727   if (arg1) (arg1)->scale = *arg2;
72728 }
72729
72730
72731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
72732   void * jresult ;
72733   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72734   Dali::Toolkit::ClampState2D *result = 0 ;
72735
72736   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72737   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
72738   jresult = (void *)result;
72739   return jresult;
72740 }
72741
72742
72743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
72744   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72745   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72746
72747   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72748   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72749   if (arg1) (arg1)->position = *arg2;
72750 }
72751
72752
72753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
72754   void * jresult ;
72755   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72756   Dali::Toolkit::ClampState2D *result = 0 ;
72757
72758   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72759   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
72760   jresult = (void *)result;
72761   return jresult;
72762 }
72763
72764
72765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
72766   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72767   Dali::Toolkit::ClampState arg2 ;
72768
72769   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72770   arg2 = (Dali::Toolkit::ClampState)jarg2;
72771   if (arg1) (arg1)->rotation = arg2;
72772 }
72773
72774
72775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
72776   int jresult ;
72777   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72778   Dali::Toolkit::ClampState result;
72779
72780   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72781   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
72782   jresult = (int)result;
72783   return jresult;
72784 }
72785
72786
72787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
72788   void * jresult ;
72789   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
72790
72791   {
72792     try {
72793       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
72794     } catch (std::out_of_range& e) {
72795       {
72796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72797       };
72798     } catch (std::exception& e) {
72799       {
72800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72801       };
72802     } catch (...) {
72803       {
72804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72805       };
72806     }
72807   }
72808   jresult = (void *)result;
72809   return jresult;
72810 }
72811
72812
72813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
72814   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72815
72816   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72817   {
72818     try {
72819       delete arg1;
72820     } catch (std::out_of_range& e) {
72821       {
72822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72823       };
72824     } catch (std::exception& e) {
72825       {
72826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72827       };
72828     } catch (...) {
72829       {
72830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72831       };
72832     }
72833   }
72834 }
72835
72836
72837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
72838   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72839   Dali::Toolkit::SnapType arg2 ;
72840
72841   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72842   arg2 = (Dali::Toolkit::SnapType)jarg2;
72843   if (arg1) (arg1)->type = arg2;
72844 }
72845
72846
72847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
72848   int jresult ;
72849   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72850   Dali::Toolkit::SnapType result;
72851
72852   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72853   result = (Dali::Toolkit::SnapType) ((arg1)->type);
72854   jresult = (int)result;
72855   return jresult;
72856 }
72857
72858
72859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
72860   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72861   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
72862
72863   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72864   arg2 = (Dali::Vector2 *)jarg2;
72865   if (arg1) (arg1)->position = *arg2;
72866 }
72867
72868
72869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
72870   void * jresult ;
72871   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72872   Dali::Vector2 *result = 0 ;
72873
72874   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72875   result = (Dali::Vector2 *)& ((arg1)->position);
72876   jresult = (void *)result;
72877   return jresult;
72878 }
72879
72880
72881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
72882   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72883   float arg2 ;
72884
72885   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72886   arg2 = (float)jarg2;
72887   if (arg1) (arg1)->duration = arg2;
72888 }
72889
72890
72891 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
72892   float jresult ;
72893   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72894   float result;
72895
72896   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72897   result = (float) ((arg1)->duration);
72898   jresult = result;
72899   return jresult;
72900 }
72901
72902
72903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
72904   void * jresult ;
72905   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
72906
72907   {
72908     try {
72909       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
72910     } catch (std::out_of_range& e) {
72911       {
72912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72913       };
72914     } catch (std::exception& e) {
72915       {
72916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72917       };
72918     } catch (...) {
72919       {
72920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72921       };
72922     }
72923   }
72924   jresult = (void *)result;
72925   return jresult;
72926 }
72927
72928
72929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
72930   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72931
72932   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72933   {
72934     try {
72935       delete arg1;
72936     } catch (std::out_of_range& e) {
72937       {
72938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72939       };
72940     } catch (std::exception& e) {
72941       {
72942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72943       };
72944     } catch (...) {
72945       {
72946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72947       };
72948     }
72949   }
72950 }
72951
72952
72953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
72954   int jresult ;
72955   int result;
72956
72957   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
72958   jresult = (int)result;
72959   return jresult;
72960 }
72961
72962
72963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
72964   int jresult ;
72965   int result;
72966
72967   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
72968   jresult = (int)result;
72969   return jresult;
72970 }
72971
72972
72973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
72974   int jresult ;
72975   int result;
72976
72977   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
72978   jresult = (int)result;
72979   return jresult;
72980 }
72981
72982
72983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
72984   int jresult ;
72985   int result;
72986
72987   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
72988   jresult = (int)result;
72989   return jresult;
72990 }
72991
72992
72993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
72994   int jresult ;
72995   int result;
72996
72997   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
72998   jresult = (int)result;
72999   return jresult;
73000 }
73001
73002
73003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
73004   int jresult ;
73005   int result;
73006
73007   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
73008   jresult = (int)result;
73009   return jresult;
73010 }
73011
73012
73013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
73014   int jresult ;
73015   int result;
73016
73017   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
73018   jresult = (int)result;
73019   return jresult;
73020 }
73021
73022
73023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
73024   int jresult ;
73025   int result;
73026
73027   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
73028   jresult = (int)result;
73029   return jresult;
73030 }
73031
73032
73033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
73034   int jresult ;
73035   int result;
73036
73037   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
73038   jresult = (int)result;
73039   return jresult;
73040 }
73041
73042
73043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
73044   int jresult ;
73045   int result;
73046
73047   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
73048   jresult = (int)result;
73049   return jresult;
73050 }
73051
73052
73053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
73054   int jresult ;
73055   int result;
73056
73057   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
73058   jresult = (int)result;
73059   return jresult;
73060 }
73061
73062
73063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
73064   int jresult ;
73065   int result;
73066
73067   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
73068   jresult = (int)result;
73069   return jresult;
73070 }
73071
73072
73073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
73074   int jresult ;
73075   int result;
73076
73077   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
73078   jresult = (int)result;
73079   return jresult;
73080 }
73081
73082
73083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
73084   int jresult ;
73085   int result;
73086
73087   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
73088   jresult = (int)result;
73089   return jresult;
73090 }
73091
73092
73093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
73094   int jresult ;
73095   int result;
73096
73097   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
73098   jresult = (int)result;
73099   return jresult;
73100 }
73101
73102
73103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
73104   int jresult ;
73105   int result;
73106
73107   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
73108   jresult = (int)result;
73109   return jresult;
73110 }
73111
73112
73113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
73114   int jresult ;
73115   int result;
73116
73117   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
73118   jresult = (int)result;
73119   return jresult;
73120 }
73121
73122
73123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
73124   int jresult ;
73125   int result;
73126
73127   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
73128   jresult = (int)result;
73129   return jresult;
73130 }
73131
73132
73133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
73134   int jresult ;
73135   int result;
73136
73137   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
73138   jresult = (int)result;
73139   return jresult;
73140 }
73141
73142
73143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
73144   int jresult ;
73145   int result;
73146
73147   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
73148   jresult = (int)result;
73149   return jresult;
73150 }
73151
73152
73153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
73154   int jresult ;
73155   int result;
73156
73157   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
73158   jresult = (int)result;
73159   return jresult;
73160 }
73161
73162
73163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
73164   int jresult ;
73165   int result;
73166
73167   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
73168   jresult = (int)result;
73169   return jresult;
73170 }
73171
73172
73173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
73174   int jresult ;
73175   int result;
73176
73177   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
73178   jresult = (int)result;
73179   return jresult;
73180 }
73181
73182
73183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
73184   int jresult ;
73185   int result;
73186
73187   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
73188   jresult = (int)result;
73189   return jresult;
73190 }
73191
73192
73193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
73194   int jresult ;
73195   int result;
73196
73197   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
73198   jresult = (int)result;
73199   return jresult;
73200 }
73201
73202
73203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
73204   void * jresult ;
73205   Dali::Toolkit::ScrollView::Property *result = 0 ;
73206
73207   {
73208     try {
73209       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
73210     } catch (std::out_of_range& e) {
73211       {
73212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73213       };
73214     } catch (std::exception& e) {
73215       {
73216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73217       };
73218     } catch (...) {
73219       {
73220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73221       };
73222     }
73223   }
73224   jresult = (void *)result;
73225   return jresult;
73226 }
73227
73228
73229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
73230   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
73231
73232   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
73233   {
73234     try {
73235       delete arg1;
73236     } catch (std::out_of_range& e) {
73237       {
73238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73239       };
73240     } catch (std::exception& e) {
73241       {
73242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73243       };
73244     } catch (...) {
73245       {
73246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73247       };
73248     }
73249   }
73250 }
73251
73252
73253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
73254   void * jresult ;
73255   Dali::Toolkit::ScrollView *result = 0 ;
73256
73257   {
73258     try {
73259       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
73260     } catch (std::out_of_range& e) {
73261       {
73262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73263       };
73264     } catch (std::exception& e) {
73265       {
73266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73267       };
73268     } catch (...) {
73269       {
73270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73271       };
73272     }
73273   }
73274   jresult = (void *)result;
73275   return jresult;
73276 }
73277
73278
73279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
73280   void * jresult ;
73281   Dali::Toolkit::ScrollView *arg1 = 0 ;
73282   Dali::Toolkit::ScrollView *result = 0 ;
73283
73284   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73285   if (!arg1) {
73286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
73287     return 0;
73288   }
73289   {
73290     try {
73291       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
73292     } catch (std::out_of_range& e) {
73293       {
73294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73295       };
73296     } catch (std::exception& e) {
73297       {
73298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73299       };
73300     } catch (...) {
73301       {
73302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73303       };
73304     }
73305   }
73306   jresult = (void *)result;
73307   return jresult;
73308 }
73309
73310
73311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
73312   void * jresult ;
73313   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73314   Dali::Toolkit::ScrollView *arg2 = 0 ;
73315   Dali::Toolkit::ScrollView *result = 0 ;
73316
73317   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73318   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
73319   if (!arg2) {
73320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
73321     return 0;
73322   }
73323   {
73324     try {
73325       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
73326     } catch (std::out_of_range& e) {
73327       {
73328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73329       };
73330     } catch (std::exception& e) {
73331       {
73332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73333       };
73334     } catch (...) {
73335       {
73336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73337       };
73338     }
73339   }
73340   jresult = (void *)result;
73341   return jresult;
73342 }
73343
73344
73345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
73346   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73347
73348   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73349   {
73350     try {
73351       delete arg1;
73352     } catch (std::out_of_range& e) {
73353       {
73354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73355       };
73356     } catch (std::exception& e) {
73357       {
73358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73359       };
73360     } catch (...) {
73361       {
73362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73363       };
73364     }
73365   }
73366 }
73367
73368
73369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
73370   void * jresult ;
73371   Dali::Toolkit::ScrollView result;
73372
73373   {
73374     try {
73375       result = Dali::Toolkit::ScrollView::New();
73376     } catch (std::out_of_range& e) {
73377       {
73378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73379       };
73380     } catch (std::exception& e) {
73381       {
73382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73383       };
73384     } catch (...) {
73385       {
73386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73387       };
73388     }
73389   }
73390   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
73391   return jresult;
73392 }
73393
73394
73395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
73396   void * jresult ;
73397   Dali::BaseHandle arg1 ;
73398   Dali::BaseHandle *argp1 ;
73399   Dali::Toolkit::ScrollView result;
73400
73401   argp1 = (Dali::BaseHandle *)jarg1;
73402   if (!argp1) {
73403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73404     return 0;
73405   }
73406   arg1 = *argp1;
73407   {
73408     try {
73409       result = Dali::Toolkit::ScrollView::DownCast(arg1);
73410     } catch (std::out_of_range& e) {
73411       {
73412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73413       };
73414     } catch (std::exception& e) {
73415       {
73416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73417       };
73418     } catch (...) {
73419       {
73420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73421       };
73422     }
73423   }
73424   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
73425   return jresult;
73426 }
73427
73428
73429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
73430   void * jresult ;
73431   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73432   Dali::AlphaFunction result;
73433
73434   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73435   {
73436     try {
73437       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
73438     } catch (std::out_of_range& e) {
73439       {
73440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73441       };
73442     } catch (std::exception& e) {
73443       {
73444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73445       };
73446     } catch (...) {
73447       {
73448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73449       };
73450     }
73451   }
73452   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
73453   return jresult;
73454 }
73455
73456
73457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
73458   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73459   Dali::AlphaFunction arg2 ;
73460   Dali::AlphaFunction *argp2 ;
73461
73462   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73463   argp2 = (Dali::AlphaFunction *)jarg2;
73464   if (!argp2) {
73465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73466     return ;
73467   }
73468   arg2 = *argp2;
73469   {
73470     try {
73471       (arg1)->SetScrollSnapAlphaFunction(arg2);
73472     } catch (std::out_of_range& e) {
73473       {
73474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73475       };
73476     } catch (std::exception& e) {
73477       {
73478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73479       };
73480     } catch (...) {
73481       {
73482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73483       };
73484     }
73485   }
73486 }
73487
73488
73489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
73490   void * jresult ;
73491   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73492   Dali::AlphaFunction result;
73493
73494   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73495   {
73496     try {
73497       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
73498     } catch (std::out_of_range& e) {
73499       {
73500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73501       };
73502     } catch (std::exception& e) {
73503       {
73504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73505       };
73506     } catch (...) {
73507       {
73508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73509       };
73510     }
73511   }
73512   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
73513   return jresult;
73514 }
73515
73516
73517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
73518   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73519   Dali::AlphaFunction arg2 ;
73520   Dali::AlphaFunction *argp2 ;
73521
73522   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73523   argp2 = (Dali::AlphaFunction *)jarg2;
73524   if (!argp2) {
73525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73526     return ;
73527   }
73528   arg2 = *argp2;
73529   {
73530     try {
73531       (arg1)->SetScrollFlickAlphaFunction(arg2);
73532     } catch (std::out_of_range& e) {
73533       {
73534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73535       };
73536     } catch (std::exception& e) {
73537       {
73538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73539       };
73540     } catch (...) {
73541       {
73542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73543       };
73544     }
73545   }
73546 }
73547
73548
73549 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
73550   float jresult ;
73551   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73552   float result;
73553
73554   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73555   {
73556     try {
73557       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
73558     } catch (std::out_of_range& e) {
73559       {
73560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73561       };
73562     } catch (std::exception& e) {
73563       {
73564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73565       };
73566     } catch (...) {
73567       {
73568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73569       };
73570     }
73571   }
73572   jresult = result;
73573   return jresult;
73574 }
73575
73576
73577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
73578   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73579   float arg2 ;
73580
73581   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73582   arg2 = (float)jarg2;
73583   {
73584     try {
73585       (arg1)->SetScrollSnapDuration(arg2);
73586     } catch (std::out_of_range& e) {
73587       {
73588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73589       };
73590     } catch (std::exception& e) {
73591       {
73592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73593       };
73594     } catch (...) {
73595       {
73596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73597       };
73598     }
73599   }
73600 }
73601
73602
73603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
73604   float jresult ;
73605   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73606   float result;
73607
73608   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73609   {
73610     try {
73611       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
73612     } catch (std::out_of_range& e) {
73613       {
73614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73615       };
73616     } catch (std::exception& e) {
73617       {
73618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73619       };
73620     } catch (...) {
73621       {
73622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73623       };
73624     }
73625   }
73626   jresult = result;
73627   return jresult;
73628 }
73629
73630
73631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
73632   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73633   float arg2 ;
73634
73635   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73636   arg2 = (float)jarg2;
73637   {
73638     try {
73639       (arg1)->SetScrollFlickDuration(arg2);
73640     } catch (std::out_of_range& e) {
73641       {
73642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73643       };
73644     } catch (std::exception& e) {
73645       {
73646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73647       };
73648     } catch (...) {
73649       {
73650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73651       };
73652     }
73653   }
73654 }
73655
73656
73657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
73658   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73659   Dali::Toolkit::RulerPtr arg2 ;
73660   Dali::Toolkit::RulerPtr *argp2 ;
73661
73662   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73663   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73664   if (!argp2) {
73665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73666     return ;
73667   }
73668   arg2 = *argp2;
73669   {
73670     try {
73671       (arg1)->SetRulerX(arg2);
73672     } catch (std::out_of_range& e) {
73673       {
73674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73675       };
73676     } catch (std::exception& e) {
73677       {
73678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73679       };
73680     } catch (...) {
73681       {
73682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73683       };
73684     }
73685   }
73686 }
73687
73688
73689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
73690   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73691   Dali::Toolkit::RulerPtr arg2 ;
73692   Dali::Toolkit::RulerPtr *argp2 ;
73693
73694   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73695   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73696   if (!argp2) {
73697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73698     return ;
73699   }
73700   arg2 = *argp2;
73701   {
73702     try {
73703       (arg1)->SetRulerY(arg2);
73704     } catch (std::out_of_range& e) {
73705       {
73706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73707       };
73708     } catch (std::exception& e) {
73709       {
73710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73711       };
73712     } catch (...) {
73713       {
73714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73715       };
73716     }
73717   }
73718 }
73719
73720
73721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
73722   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73723   bool arg2 ;
73724
73725   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73726   arg2 = jarg2 ? true : false;
73727   {
73728     try {
73729       (arg1)->SetScrollSensitive(arg2);
73730     } catch (std::out_of_range& e) {
73731       {
73732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73733       };
73734     } catch (std::exception& e) {
73735       {
73736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73737       };
73738     } catch (...) {
73739       {
73740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73741       };
73742     }
73743   }
73744 }
73745
73746
73747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
73748   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73749   float arg2 ;
73750   float arg3 ;
73751
73752   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73753   arg2 = (float)jarg2;
73754   arg3 = (float)jarg3;
73755   {
73756     try {
73757       (arg1)->SetMaxOvershoot(arg2,arg3);
73758     } catch (std::out_of_range& e) {
73759       {
73760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73761       };
73762     } catch (std::exception& e) {
73763       {
73764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73765       };
73766     } catch (...) {
73767       {
73768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73769       };
73770     }
73771   }
73772 }
73773
73774
73775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
73776   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73777   Dali::AlphaFunction arg2 ;
73778   Dali::AlphaFunction *argp2 ;
73779
73780   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73781   argp2 = (Dali::AlphaFunction *)jarg2;
73782   if (!argp2) {
73783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73784     return ;
73785   }
73786   arg2 = *argp2;
73787   {
73788     try {
73789       (arg1)->SetSnapOvershootAlphaFunction(arg2);
73790     } catch (std::out_of_range& e) {
73791       {
73792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73793       };
73794     } catch (std::exception& e) {
73795       {
73796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73797       };
73798     } catch (...) {
73799       {
73800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73801       };
73802     }
73803   }
73804 }
73805
73806
73807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
73808   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73809   float arg2 ;
73810
73811   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73812   arg2 = (float)jarg2;
73813   {
73814     try {
73815       (arg1)->SetSnapOvershootDuration(arg2);
73816     } catch (std::out_of_range& e) {
73817       {
73818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73819       };
73820     } catch (std::exception& e) {
73821       {
73822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73823       };
73824     } catch (...) {
73825       {
73826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73827       };
73828     }
73829   }
73830 }
73831
73832
73833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
73834   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73835   bool arg2 ;
73836
73837   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73838   arg2 = jarg2 ? true : false;
73839   {
73840     try {
73841       (arg1)->SetActorAutoSnap(arg2);
73842     } catch (std::out_of_range& e) {
73843       {
73844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73845       };
73846     } catch (std::exception& e) {
73847       {
73848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73849       };
73850     } catch (...) {
73851       {
73852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73853       };
73854     }
73855   }
73856 }
73857
73858
73859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
73860   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73861   bool arg2 ;
73862
73863   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73864   arg2 = jarg2 ? true : false;
73865   {
73866     try {
73867       (arg1)->SetWrapMode(arg2);
73868     } catch (std::out_of_range& e) {
73869       {
73870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73871       };
73872     } catch (std::exception& e) {
73873       {
73874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73875       };
73876     } catch (...) {
73877       {
73878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73879       };
73880     }
73881   }
73882 }
73883
73884
73885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
73886   int jresult ;
73887   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73888   int result;
73889
73890   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73891   {
73892     try {
73893       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
73894     } catch (std::out_of_range& e) {
73895       {
73896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73897       };
73898     } catch (std::exception& e) {
73899       {
73900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73901       };
73902     } catch (...) {
73903       {
73904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73905       };
73906     }
73907   }
73908   jresult = result;
73909   return jresult;
73910 }
73911
73912
73913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
73914   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73915   int arg2 ;
73916
73917   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73918   arg2 = (int)jarg2;
73919   {
73920     try {
73921       (arg1)->SetScrollUpdateDistance(arg2);
73922     } catch (std::out_of_range& e) {
73923       {
73924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73925       };
73926     } catch (std::exception& e) {
73927       {
73928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73929       };
73930     } catch (...) {
73931       {
73932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73933       };
73934     }
73935   }
73936 }
73937
73938
73939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
73940   unsigned int jresult ;
73941   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73942   bool result;
73943
73944   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73945   {
73946     try {
73947       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
73948     } catch (std::out_of_range& e) {
73949       {
73950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73951       };
73952     } catch (std::exception& e) {
73953       {
73954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73955       };
73956     } catch (...) {
73957       {
73958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73959       };
73960     }
73961   }
73962   jresult = result;
73963   return jresult;
73964 }
73965
73966
73967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
73968   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73969   bool arg2 ;
73970
73971   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73972   arg2 = jarg2 ? true : false;
73973   {
73974     try {
73975       (arg1)->SetAxisAutoLock(arg2);
73976     } catch (std::out_of_range& e) {
73977       {
73978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73979       };
73980     } catch (std::exception& e) {
73981       {
73982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73983       };
73984     } catch (...) {
73985       {
73986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73987       };
73988     }
73989   }
73990 }
73991
73992
73993 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
73994   float jresult ;
73995   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73996   float result;
73997
73998   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73999   {
74000     try {
74001       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
74002     } catch (std::out_of_range& e) {
74003       {
74004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74005       };
74006     } catch (std::exception& e) {
74007       {
74008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74009       };
74010     } catch (...) {
74011       {
74012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74013       };
74014     }
74015   }
74016   jresult = result;
74017   return jresult;
74018 }
74019
74020
74021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
74022   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74023   float arg2 ;
74024
74025   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74026   arg2 = (float)jarg2;
74027   {
74028     try {
74029       (arg1)->SetAxisAutoLockGradient(arg2);
74030     } catch (std::out_of_range& e) {
74031       {
74032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74033       };
74034     } catch (std::exception& e) {
74035       {
74036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74037       };
74038     } catch (...) {
74039       {
74040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74041       };
74042     }
74043   }
74044 }
74045
74046
74047 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
74048   float jresult ;
74049   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74050   float result;
74051
74052   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74053   {
74054     try {
74055       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
74056     } catch (std::out_of_range& e) {
74057       {
74058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74059       };
74060     } catch (std::exception& e) {
74061       {
74062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74063       };
74064     } catch (...) {
74065       {
74066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74067       };
74068     }
74069   }
74070   jresult = result;
74071   return jresult;
74072 }
74073
74074
74075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
74076   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74077   float arg2 ;
74078
74079   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74080   arg2 = (float)jarg2;
74081   {
74082     try {
74083       (arg1)->SetFrictionCoefficient(arg2);
74084     } catch (std::out_of_range& e) {
74085       {
74086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74087       };
74088     } catch (std::exception& e) {
74089       {
74090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74091       };
74092     } catch (...) {
74093       {
74094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74095       };
74096     }
74097   }
74098 }
74099
74100
74101 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
74102   float jresult ;
74103   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74104   float result;
74105
74106   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74107   {
74108     try {
74109       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
74110     } catch (std::out_of_range& e) {
74111       {
74112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74113       };
74114     } catch (std::exception& e) {
74115       {
74116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74117       };
74118     } catch (...) {
74119       {
74120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74121       };
74122     }
74123   }
74124   jresult = result;
74125   return jresult;
74126 }
74127
74128
74129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
74130   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74131   float arg2 ;
74132
74133   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74134   arg2 = (float)jarg2;
74135   {
74136     try {
74137       (arg1)->SetFlickSpeedCoefficient(arg2);
74138     } catch (std::out_of_range& e) {
74139       {
74140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74141       };
74142     } catch (std::exception& e) {
74143       {
74144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74145       };
74146     } catch (...) {
74147       {
74148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74149       };
74150     }
74151   }
74152 }
74153
74154
74155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
74156   void * jresult ;
74157   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74158   Dali::Vector2 result;
74159
74160   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74161   {
74162     try {
74163       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
74164     } catch (std::out_of_range& e) {
74165       {
74166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74167       };
74168     } catch (std::exception& e) {
74169       {
74170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74171       };
74172     } catch (...) {
74173       {
74174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74175       };
74176     }
74177   }
74178   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74179   return jresult;
74180 }
74181
74182
74183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
74184   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74185   Dali::Vector2 *arg2 = 0 ;
74186
74187   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74188   arg2 = (Dali::Vector2 *)jarg2;
74189   if (!arg2) {
74190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74191     return ;
74192   }
74193   {
74194     try {
74195       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
74196     } catch (std::out_of_range& e) {
74197       {
74198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74199       };
74200     } catch (std::exception& e) {
74201       {
74202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74203       };
74204     } catch (...) {
74205       {
74206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74207       };
74208     }
74209   }
74210 }
74211
74212
74213 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
74214   float jresult ;
74215   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74216   float result;
74217
74218   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74219   {
74220     try {
74221       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
74222     } catch (std::out_of_range& e) {
74223       {
74224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74225       };
74226     } catch (std::exception& e) {
74227       {
74228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74229       };
74230     } catch (...) {
74231       {
74232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74233       };
74234     }
74235   }
74236   jresult = result;
74237   return jresult;
74238 }
74239
74240
74241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
74242   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74243   float arg2 ;
74244
74245   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74246   arg2 = (float)jarg2;
74247   {
74248     try {
74249       (arg1)->SetMinimumSpeedForFlick(arg2);
74250     } catch (std::out_of_range& e) {
74251       {
74252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74253       };
74254     } catch (std::exception& e) {
74255       {
74256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74257       };
74258     } catch (...) {
74259       {
74260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74261       };
74262     }
74263   }
74264 }
74265
74266
74267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
74268   float jresult ;
74269   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74270   float result;
74271
74272   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74273   {
74274     try {
74275       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
74276     } catch (std::out_of_range& e) {
74277       {
74278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74279       };
74280     } catch (std::exception& e) {
74281       {
74282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74283       };
74284     } catch (...) {
74285       {
74286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74287       };
74288     }
74289   }
74290   jresult = result;
74291   return jresult;
74292 }
74293
74294
74295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
74296   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74297   float arg2 ;
74298
74299   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74300   arg2 = (float)jarg2;
74301   {
74302     try {
74303       (arg1)->SetMaxFlickSpeed(arg2);
74304     } catch (std::out_of_range& e) {
74305       {
74306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74307       };
74308     } catch (std::exception& e) {
74309       {
74310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74311       };
74312     } catch (...) {
74313       {
74314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74315       };
74316     }
74317   }
74318 }
74319
74320
74321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
74322   void * jresult ;
74323   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74324   Dali::Vector2 result;
74325
74326   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74327   {
74328     try {
74329       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
74330     } catch (std::out_of_range& e) {
74331       {
74332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74333       };
74334     } catch (std::exception& e) {
74335       {
74336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74337       };
74338     } catch (...) {
74339       {
74340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74341       };
74342     }
74343   }
74344   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74345   return jresult;
74346 }
74347
74348
74349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
74350   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74351   Dali::Vector2 arg2 ;
74352   Dali::Vector2 *argp2 ;
74353
74354   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74355   argp2 = (Dali::Vector2 *)jarg2;
74356   if (!argp2) {
74357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
74358     return ;
74359   }
74360   arg2 = *argp2;
74361   {
74362     try {
74363       (arg1)->SetWheelScrollDistanceStep(arg2);
74364     } catch (std::out_of_range& e) {
74365       {
74366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74367       };
74368     } catch (std::exception& e) {
74369       {
74370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74371       };
74372     } catch (...) {
74373       {
74374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74375       };
74376     }
74377   }
74378 }
74379
74380
74381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
74382   void * jresult ;
74383   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74384   Dali::Vector2 result;
74385
74386   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74387   {
74388     try {
74389       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
74390     } catch (std::out_of_range& e) {
74391       {
74392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74393       };
74394     } catch (std::exception& e) {
74395       {
74396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74397       };
74398     } catch (...) {
74399       {
74400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74401       };
74402     }
74403   }
74404   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74405   return jresult;
74406 }
74407
74408
74409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
74410   unsigned int jresult ;
74411   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74412   unsigned int result;
74413
74414   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74415   {
74416     try {
74417       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
74418     } catch (std::out_of_range& e) {
74419       {
74420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74421       };
74422     } catch (std::exception& e) {
74423       {
74424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74425       };
74426     } catch (...) {
74427       {
74428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74429       };
74430     }
74431   }
74432   jresult = result;
74433   return jresult;
74434 }
74435
74436
74437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
74438   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74439   Dali::Vector2 *arg2 = 0 ;
74440
74441   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74442   arg2 = (Dali::Vector2 *)jarg2;
74443   if (!arg2) {
74444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74445     return ;
74446   }
74447   {
74448     try {
74449       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
74450     } catch (std::out_of_range& e) {
74451       {
74452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74453       };
74454     } catch (std::exception& e) {
74455       {
74456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74457       };
74458     } catch (...) {
74459       {
74460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74461       };
74462     }
74463   }
74464 }
74465
74466
74467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
74468   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74469   Dali::Vector2 *arg2 = 0 ;
74470   float arg3 ;
74471
74472   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74473   arg2 = (Dali::Vector2 *)jarg2;
74474   if (!arg2) {
74475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74476     return ;
74477   }
74478   arg3 = (float)jarg3;
74479   {
74480     try {
74481       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
74482     } catch (std::out_of_range& e) {
74483       {
74484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74485       };
74486     } catch (std::exception& e) {
74487       {
74488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74489       };
74490     } catch (...) {
74491       {
74492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74493       };
74494     }
74495   }
74496 }
74497
74498
74499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
74500   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74501   Dali::Vector2 *arg2 = 0 ;
74502   float arg3 ;
74503   Dali::AlphaFunction arg4 ;
74504   Dali::AlphaFunction *argp4 ;
74505
74506   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74507   arg2 = (Dali::Vector2 *)jarg2;
74508   if (!arg2) {
74509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74510     return ;
74511   }
74512   arg3 = (float)jarg3;
74513   argp4 = (Dali::AlphaFunction *)jarg4;
74514   if (!argp4) {
74515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74516     return ;
74517   }
74518   arg4 = *argp4;
74519   {
74520     try {
74521       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
74522     } catch (std::out_of_range& e) {
74523       {
74524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74525       };
74526     } catch (std::exception& e) {
74527       {
74528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74529       };
74530     } catch (...) {
74531       {
74532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74533       };
74534     }
74535   }
74536 }
74537
74538
74539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
74540   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74541   Dali::Vector2 *arg2 = 0 ;
74542   float arg3 ;
74543   Dali::Toolkit::DirectionBias arg4 ;
74544   Dali::Toolkit::DirectionBias arg5 ;
74545
74546   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74547   arg2 = (Dali::Vector2 *)jarg2;
74548   if (!arg2) {
74549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74550     return ;
74551   }
74552   arg3 = (float)jarg3;
74553   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74554   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74555   {
74556     try {
74557       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
74558     } catch (std::out_of_range& e) {
74559       {
74560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74561       };
74562     } catch (std::exception& e) {
74563       {
74564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74565       };
74566     } catch (...) {
74567       {
74568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74569       };
74570     }
74571   }
74572 }
74573
74574
74575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
74576   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74577   Dali::Vector2 *arg2 = 0 ;
74578   float arg3 ;
74579   Dali::AlphaFunction arg4 ;
74580   Dali::Toolkit::DirectionBias arg5 ;
74581   Dali::Toolkit::DirectionBias arg6 ;
74582   Dali::AlphaFunction *argp4 ;
74583
74584   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74585   arg2 = (Dali::Vector2 *)jarg2;
74586   if (!arg2) {
74587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74588     return ;
74589   }
74590   arg3 = (float)jarg3;
74591   argp4 = (Dali::AlphaFunction *)jarg4;
74592   if (!argp4) {
74593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74594     return ;
74595   }
74596   arg4 = *argp4;
74597   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74598   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
74599   {
74600     try {
74601       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
74602     } catch (std::out_of_range& e) {
74603       {
74604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74605       };
74606     } catch (std::exception& e) {
74607       {
74608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74609       };
74610     } catch (...) {
74611       {
74612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74613       };
74614     }
74615   }
74616 }
74617
74618
74619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
74620   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74621   unsigned int arg2 ;
74622
74623   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74624   arg2 = (unsigned int)jarg2;
74625   {
74626     try {
74627       (arg1)->ScrollTo(arg2);
74628     } catch (std::out_of_range& e) {
74629       {
74630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74631       };
74632     } catch (std::exception& e) {
74633       {
74634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74635       };
74636     } catch (...) {
74637       {
74638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74639       };
74640     }
74641   }
74642 }
74643
74644
74645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
74646   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74647   unsigned int arg2 ;
74648   float arg3 ;
74649
74650   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74651   arg2 = (unsigned int)jarg2;
74652   arg3 = (float)jarg3;
74653   {
74654     try {
74655       (arg1)->ScrollTo(arg2,arg3);
74656     } catch (std::out_of_range& e) {
74657       {
74658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74659       };
74660     } catch (std::exception& e) {
74661       {
74662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74663       };
74664     } catch (...) {
74665       {
74666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74667       };
74668     }
74669   }
74670 }
74671
74672
74673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
74674   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74675   unsigned int arg2 ;
74676   float arg3 ;
74677   Dali::Toolkit::DirectionBias arg4 ;
74678
74679   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74680   arg2 = (unsigned int)jarg2;
74681   arg3 = (float)jarg3;
74682   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74683   {
74684     try {
74685       (arg1)->ScrollTo(arg2,arg3,arg4);
74686     } catch (std::out_of_range& e) {
74687       {
74688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74689       };
74690     } catch (std::exception& e) {
74691       {
74692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74693       };
74694     } catch (...) {
74695       {
74696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74697       };
74698     }
74699   }
74700 }
74701
74702
74703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
74704   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74705   Dali::Actor *arg2 = 0 ;
74706
74707   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74708   arg2 = (Dali::Actor *)jarg2;
74709   if (!arg2) {
74710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74711     return ;
74712   }
74713   {
74714     try {
74715       (arg1)->ScrollTo(*arg2);
74716     } catch (std::out_of_range& e) {
74717       {
74718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74719       };
74720     } catch (std::exception& e) {
74721       {
74722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74723       };
74724     } catch (...) {
74725       {
74726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74727       };
74728     }
74729   }
74730 }
74731
74732
74733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
74734   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74735   Dali::Actor *arg2 = 0 ;
74736   float arg3 ;
74737
74738   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74739   arg2 = (Dali::Actor *)jarg2;
74740   if (!arg2) {
74741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74742     return ;
74743   }
74744   arg3 = (float)jarg3;
74745   {
74746     try {
74747       (arg1)->ScrollTo(*arg2,arg3);
74748     } catch (std::out_of_range& e) {
74749       {
74750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74751       };
74752     } catch (std::exception& e) {
74753       {
74754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74755       };
74756     } catch (...) {
74757       {
74758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74759       };
74760     }
74761   }
74762 }
74763
74764
74765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
74766   unsigned int jresult ;
74767   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74768   bool result;
74769
74770   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74771   {
74772     try {
74773       result = (bool)(arg1)->ScrollToSnapPoint();
74774     } catch (std::out_of_range& e) {
74775       {
74776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74777       };
74778     } catch (std::exception& e) {
74779       {
74780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74781       };
74782     } catch (...) {
74783       {
74784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74785       };
74786     }
74787   }
74788   jresult = result;
74789   return jresult;
74790 }
74791
74792
74793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
74794   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74795   Dali::Constraint arg2 ;
74796   Dali::Constraint *argp2 ;
74797
74798   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74799   argp2 = (Dali::Constraint *)jarg2;
74800   if (!argp2) {
74801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
74802     return ;
74803   }
74804   arg2 = *argp2;
74805   {
74806     try {
74807       (arg1)->ApplyConstraintToChildren(arg2);
74808     } catch (std::out_of_range& e) {
74809       {
74810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74811       };
74812     } catch (std::exception& e) {
74813       {
74814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74815       };
74816     } catch (...) {
74817       {
74818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74819       };
74820     }
74821   }
74822 }
74823
74824
74825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
74826   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74827
74828   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74829   {
74830     try {
74831       (arg1)->RemoveConstraintsFromChildren();
74832     } catch (std::out_of_range& e) {
74833       {
74834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74835       };
74836     } catch (std::exception& e) {
74837       {
74838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74839       };
74840     } catch (...) {
74841       {
74842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74843       };
74844     }
74845   }
74846 }
74847
74848
74849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
74850   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74851   Dali::Toolkit::ScrollViewEffect arg2 ;
74852   Dali::Toolkit::ScrollViewEffect *argp2 ;
74853
74854   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74855   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
74856   if (!argp2) {
74857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
74858     return ;
74859   }
74860   arg2 = *argp2;
74861   {
74862     try {
74863       (arg1)->ApplyEffect(arg2);
74864     } catch (std::out_of_range& e) {
74865       {
74866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74867       };
74868     } catch (std::exception& e) {
74869       {
74870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74871       };
74872     } catch (...) {
74873       {
74874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74875       };
74876     }
74877   }
74878 }
74879
74880
74881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
74882   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74883   Dali::Toolkit::ScrollViewEffect arg2 ;
74884   Dali::Toolkit::ScrollViewEffect *argp2 ;
74885
74886   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74887   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
74888   if (!argp2) {
74889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
74890     return ;
74891   }
74892   arg2 = *argp2;
74893   {
74894     try {
74895       (arg1)->RemoveEffect(arg2);
74896     } catch (std::out_of_range& e) {
74897       {
74898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74899       };
74900     } catch (std::exception& e) {
74901       {
74902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74903       };
74904     } catch (...) {
74905       {
74906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74907       };
74908     }
74909   }
74910 }
74911
74912
74913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
74914   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74915
74916   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74917   {
74918     try {
74919       (arg1)->RemoveAllEffects();
74920     } catch (std::out_of_range& e) {
74921       {
74922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74923       };
74924     } catch (std::exception& e) {
74925       {
74926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74927       };
74928     } catch (...) {
74929       {
74930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74931       };
74932     }
74933   }
74934 }
74935
74936
74937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
74938   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74939   Dali::Actor arg2 ;
74940   Dali::Actor *argp2 ;
74941
74942   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74943   argp2 = (Dali::Actor *)jarg2;
74944   if (!argp2) {
74945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74946     return ;
74947   }
74948   arg2 = *argp2;
74949   {
74950     try {
74951       (arg1)->BindActor(arg2);
74952     } catch (std::out_of_range& e) {
74953       {
74954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74955       };
74956     } catch (std::exception& e) {
74957       {
74958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74959       };
74960     } catch (...) {
74961       {
74962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74963       };
74964     }
74965   }
74966 }
74967
74968
74969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
74970   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74971   Dali::Actor arg2 ;
74972   Dali::Actor *argp2 ;
74973
74974   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74975   argp2 = (Dali::Actor *)jarg2;
74976   if (!argp2) {
74977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74978     return ;
74979   }
74980   arg2 = *argp2;
74981   {
74982     try {
74983       (arg1)->UnbindActor(arg2);
74984     } catch (std::out_of_range& e) {
74985       {
74986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74987       };
74988     } catch (std::exception& e) {
74989       {
74990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74991       };
74992     } catch (...) {
74993       {
74994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74995       };
74996     }
74997   }
74998 }
74999
75000
75001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
75002   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75003   Dali::Radian arg2 ;
75004   Dali::Radian arg3 ;
75005   Dali::Radian *argp2 ;
75006   Dali::Radian *argp3 ;
75007
75008   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75009   argp2 = (Dali::Radian *)jarg2;
75010   if (!argp2) {
75011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75012     return ;
75013   }
75014   arg2 = *argp2;
75015   argp3 = (Dali::Radian *)jarg3;
75016   if (!argp3) {
75017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75018     return ;
75019   }
75020   arg3 = *argp3;
75021   {
75022     try {
75023       (arg1)->SetScrollingDirection(arg2,arg3);
75024     } catch (std::out_of_range& e) {
75025       {
75026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75027       };
75028     } catch (std::exception& e) {
75029       {
75030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75031       };
75032     } catch (...) {
75033       {
75034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75035       };
75036     }
75037   }
75038 }
75039
75040
75041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
75042   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75043   Dali::Radian arg2 ;
75044   Dali::Radian *argp2 ;
75045
75046   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75047   argp2 = (Dali::Radian *)jarg2;
75048   if (!argp2) {
75049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75050     return ;
75051   }
75052   arg2 = *argp2;
75053   {
75054     try {
75055       (arg1)->SetScrollingDirection(arg2);
75056     } catch (std::out_of_range& e) {
75057       {
75058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75059       };
75060     } catch (std::exception& e) {
75061       {
75062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75063       };
75064     } catch (...) {
75065       {
75066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75067       };
75068     }
75069   }
75070 }
75071
75072
75073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
75074   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75075   Dali::Radian arg2 ;
75076   Dali::Radian *argp2 ;
75077
75078   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75079   argp2 = (Dali::Radian *)jarg2;
75080   if (!argp2) {
75081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75082     return ;
75083   }
75084   arg2 = *argp2;
75085   {
75086     try {
75087       (arg1)->RemoveScrollingDirection(arg2);
75088     } catch (std::out_of_range& e) {
75089       {
75090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75091       };
75092     } catch (std::exception& e) {
75093       {
75094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75095       };
75096     } catch (...) {
75097       {
75098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75099       };
75100     }
75101   }
75102 }
75103
75104
75105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
75106   void * jresult ;
75107   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75108   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
75109
75110   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75111   {
75112     try {
75113       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
75114     } catch (std::out_of_range& e) {
75115       {
75116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75117       };
75118     } catch (std::exception& e) {
75119       {
75120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75121       };
75122     } catch (...) {
75123       {
75124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75125       };
75126     }
75127   }
75128   jresult = (void *)result;
75129   return jresult;
75130 }
75131
75132
75133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
75134   int jresult ;
75135   int result;
75136
75137   result = (int)Dali::Toolkit::TableView::Property::ROWS;
75138   jresult = (int)result;
75139   return jresult;
75140 }
75141
75142
75143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
75144   int jresult ;
75145   int result;
75146
75147   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
75148   jresult = (int)result;
75149   return jresult;
75150 }
75151
75152
75153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
75154   int jresult ;
75155   int result;
75156
75157   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
75158   jresult = (int)result;
75159   return jresult;
75160 }
75161
75162
75163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
75164   int jresult ;
75165   int result;
75166
75167   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
75168   jresult = (int)result;
75169   return jresult;
75170 }
75171
75172
75173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
75174   int jresult ;
75175   int result;
75176
75177   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
75178   jresult = (int)result;
75179   return jresult;
75180 }
75181
75182
75183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
75184   void * jresult ;
75185   Dali::Toolkit::TableView::Property *result = 0 ;
75186
75187   {
75188     try {
75189       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
75190     } catch (std::out_of_range& e) {
75191       {
75192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75193       };
75194     } catch (std::exception& e) {
75195       {
75196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75197       };
75198     } catch (...) {
75199       {
75200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75201       };
75202     }
75203   }
75204   jresult = (void *)result;
75205   return jresult;
75206 }
75207
75208
75209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
75210   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
75211
75212   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
75213   {
75214     try {
75215       delete arg1;
75216     } catch (std::out_of_range& e) {
75217       {
75218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75219       };
75220     } catch (std::exception& e) {
75221       {
75222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75223       };
75224     } catch (...) {
75225       {
75226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75227       };
75228     }
75229   }
75230 }
75231
75232
75233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
75234   int jresult ;
75235   int result;
75236
75237   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
75238   jresult = (int)result;
75239   return jresult;
75240 }
75241
75242
75243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
75244   int jresult ;
75245   int result;
75246
75247   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
75248   jresult = (int)result;
75249   return jresult;
75250 }
75251
75252
75253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
75254   int jresult ;
75255   int result;
75256
75257   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
75258   jresult = (int)result;
75259   return jresult;
75260 }
75261
75262
75263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
75264   int jresult ;
75265   int result;
75266
75267   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
75268   jresult = (int)result;
75269   return jresult;
75270 }
75271
75272
75273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
75274   int jresult ;
75275   int result;
75276
75277   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
75278   jresult = (int)result;
75279   return jresult;
75280 }
75281
75282
75283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
75284   void * jresult ;
75285   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
75286
75287   {
75288     try {
75289       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
75290     } catch (std::out_of_range& e) {
75291       {
75292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75293       };
75294     } catch (std::exception& e) {
75295       {
75296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75297       };
75298     } catch (...) {
75299       {
75300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75301       };
75302     }
75303   }
75304   jresult = (void *)result;
75305   return jresult;
75306 }
75307
75308
75309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
75310   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
75311
75312   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
75313   {
75314     try {
75315       delete arg1;
75316     } catch (std::out_of_range& e) {
75317       {
75318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75319       };
75320     } catch (std::exception& e) {
75321       {
75322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75323       };
75324     } catch (...) {
75325       {
75326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75327       };
75328     }
75329   }
75330 }
75331
75332
75333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
75334   void * jresult ;
75335   unsigned int arg1 ;
75336   unsigned int arg2 ;
75337   unsigned int arg3 ;
75338   unsigned int arg4 ;
75339   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75340
75341   arg1 = (unsigned int)jarg1;
75342   arg2 = (unsigned int)jarg2;
75343   arg3 = (unsigned int)jarg3;
75344   arg4 = (unsigned int)jarg4;
75345   {
75346     try {
75347       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
75348     } catch (std::out_of_range& e) {
75349       {
75350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75351       };
75352     } catch (std::exception& e) {
75353       {
75354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75355       };
75356     } catch (...) {
75357       {
75358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75359       };
75360     }
75361   }
75362   jresult = (void *)result;
75363   return jresult;
75364 }
75365
75366
75367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
75368   void * jresult ;
75369   unsigned int arg1 ;
75370   unsigned int arg2 ;
75371   unsigned int arg3 ;
75372   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75373
75374   arg1 = (unsigned int)jarg1;
75375   arg2 = (unsigned int)jarg2;
75376   arg3 = (unsigned int)jarg3;
75377   {
75378     try {
75379       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
75380     } catch (std::out_of_range& e) {
75381       {
75382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75383       };
75384     } catch (std::exception& e) {
75385       {
75386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75387       };
75388     } catch (...) {
75389       {
75390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75391       };
75392     }
75393   }
75394   jresult = (void *)result;
75395   return jresult;
75396 }
75397
75398
75399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
75400   void * jresult ;
75401   unsigned int arg1 ;
75402   unsigned int arg2 ;
75403   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75404
75405   arg1 = (unsigned int)jarg1;
75406   arg2 = (unsigned int)jarg2;
75407   {
75408     try {
75409       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
75410     } catch (std::out_of_range& e) {
75411       {
75412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75413       };
75414     } catch (std::exception& e) {
75415       {
75416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75417       };
75418     } catch (...) {
75419       {
75420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75421       };
75422     }
75423   }
75424   jresult = (void *)result;
75425   return jresult;
75426 }
75427
75428
75429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
75430   void * jresult ;
75431   unsigned int arg1 ;
75432   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75433
75434   arg1 = (unsigned int)jarg1;
75435   {
75436     try {
75437       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
75438     } catch (std::out_of_range& e) {
75439       {
75440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75441       };
75442     } catch (std::exception& e) {
75443       {
75444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75445       };
75446     } catch (...) {
75447       {
75448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75449       };
75450     }
75451   }
75452   jresult = (void *)result;
75453   return jresult;
75454 }
75455
75456
75457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
75458   void * jresult ;
75459   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75460
75461   {
75462     try {
75463       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
75464     } catch (std::out_of_range& e) {
75465       {
75466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75467       };
75468     } catch (std::exception& e) {
75469       {
75470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75471       };
75472     } catch (...) {
75473       {
75474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75475       };
75476     }
75477   }
75478   jresult = (void *)result;
75479   return jresult;
75480 }
75481
75482
75483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
75484   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75485   unsigned int arg2 ;
75486
75487   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75488   arg2 = (unsigned int)jarg2;
75489   if (arg1) (arg1)->rowIndex = arg2;
75490 }
75491
75492
75493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
75494   unsigned int jresult ;
75495   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75496   unsigned int result;
75497
75498   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75499   result = (unsigned int) ((arg1)->rowIndex);
75500   jresult = result;
75501   return jresult;
75502 }
75503
75504
75505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
75506   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75507   unsigned int arg2 ;
75508
75509   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75510   arg2 = (unsigned int)jarg2;
75511   if (arg1) (arg1)->columnIndex = arg2;
75512 }
75513
75514
75515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
75516   unsigned int jresult ;
75517   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75518   unsigned int result;
75519
75520   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75521   result = (unsigned int) ((arg1)->columnIndex);
75522   jresult = result;
75523   return jresult;
75524 }
75525
75526
75527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
75528   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75529   unsigned int arg2 ;
75530
75531   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75532   arg2 = (unsigned int)jarg2;
75533   if (arg1) (arg1)->rowSpan = arg2;
75534 }
75535
75536
75537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
75538   unsigned int jresult ;
75539   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75540   unsigned int result;
75541
75542   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75543   result = (unsigned int) ((arg1)->rowSpan);
75544   jresult = result;
75545   return jresult;
75546 }
75547
75548
75549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
75550   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75551   unsigned int arg2 ;
75552
75553   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75554   arg2 = (unsigned int)jarg2;
75555   if (arg1) (arg1)->columnSpan = arg2;
75556 }
75557
75558
75559 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
75560   unsigned int jresult ;
75561   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75562   unsigned int result;
75563
75564   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75565   result = (unsigned int) ((arg1)->columnSpan);
75566   jresult = result;
75567   return jresult;
75568 }
75569
75570
75571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
75572   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75573
75574   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75575   {
75576     try {
75577       delete arg1;
75578     } catch (std::out_of_range& e) {
75579       {
75580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75581       };
75582     } catch (std::exception& e) {
75583       {
75584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75585       };
75586     } catch (...) {
75587       {
75588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75589       };
75590     }
75591   }
75592 }
75593
75594
75595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
75596   void * jresult ;
75597   Dali::Toolkit::TableView *result = 0 ;
75598
75599   {
75600     try {
75601       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
75602     } catch (std::out_of_range& e) {
75603       {
75604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75605       };
75606     } catch (std::exception& e) {
75607       {
75608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75609       };
75610     } catch (...) {
75611       {
75612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75613       };
75614     }
75615   }
75616   jresult = (void *)result;
75617   return jresult;
75618 }
75619
75620
75621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
75622   void * jresult ;
75623   Dali::Toolkit::TableView *arg1 = 0 ;
75624   Dali::Toolkit::TableView *result = 0 ;
75625
75626   arg1 = (Dali::Toolkit::TableView *)jarg1;
75627   if (!arg1) {
75628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75629     return 0;
75630   }
75631   {
75632     try {
75633       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
75634     } catch (std::out_of_range& e) {
75635       {
75636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75637       };
75638     } catch (std::exception& e) {
75639       {
75640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75641       };
75642     } catch (...) {
75643       {
75644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75645       };
75646     }
75647   }
75648   jresult = (void *)result;
75649   return jresult;
75650 }
75651
75652
75653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
75654   void * jresult ;
75655   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75656   Dali::Toolkit::TableView *arg2 = 0 ;
75657   Dali::Toolkit::TableView *result = 0 ;
75658
75659   arg1 = (Dali::Toolkit::TableView *)jarg1;
75660   arg2 = (Dali::Toolkit::TableView *)jarg2;
75661   if (!arg2) {
75662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75663     return 0;
75664   }
75665   {
75666     try {
75667       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
75668     } catch (std::out_of_range& e) {
75669       {
75670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75671       };
75672     } catch (std::exception& e) {
75673       {
75674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75675       };
75676     } catch (...) {
75677       {
75678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75679       };
75680     }
75681   }
75682   jresult = (void *)result;
75683   return jresult;
75684 }
75685
75686
75687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
75688   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75689
75690   arg1 = (Dali::Toolkit::TableView *)jarg1;
75691   {
75692     try {
75693       delete arg1;
75694     } catch (std::out_of_range& e) {
75695       {
75696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75697       };
75698     } catch (std::exception& e) {
75699       {
75700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75701       };
75702     } catch (...) {
75703       {
75704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75705       };
75706     }
75707   }
75708 }
75709
75710
75711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
75712   void * jresult ;
75713   unsigned int arg1 ;
75714   unsigned int arg2 ;
75715   Dali::Toolkit::TableView result;
75716
75717   arg1 = (unsigned int)jarg1;
75718   arg2 = (unsigned int)jarg2;
75719   {
75720     try {
75721       result = Dali::Toolkit::TableView::New(arg1,arg2);
75722     } catch (std::out_of_range& e) {
75723       {
75724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75725       };
75726     } catch (std::exception& e) {
75727       {
75728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75729       };
75730     } catch (...) {
75731       {
75732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75733       };
75734     }
75735   }
75736   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
75737   return jresult;
75738 }
75739
75740
75741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
75742   void * jresult ;
75743   Dali::BaseHandle arg1 ;
75744   Dali::BaseHandle *argp1 ;
75745   Dali::Toolkit::TableView result;
75746
75747   argp1 = (Dali::BaseHandle *)jarg1;
75748   if (!argp1) {
75749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75750     return 0;
75751   }
75752   arg1 = *argp1;
75753   {
75754     try {
75755       result = Dali::Toolkit::TableView::DownCast(arg1);
75756     } catch (std::out_of_range& e) {
75757       {
75758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75759       };
75760     } catch (std::exception& e) {
75761       {
75762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75763       };
75764     } catch (...) {
75765       {
75766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75767       };
75768     }
75769   }
75770   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
75771   return jresult;
75772 }
75773
75774
75775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
75776   unsigned int jresult ;
75777   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75778   Dali::Actor arg2 ;
75779   Dali::Toolkit::TableView::CellPosition arg3 ;
75780   Dali::Actor *argp2 ;
75781   Dali::Toolkit::TableView::CellPosition *argp3 ;
75782   bool result;
75783
75784   arg1 = (Dali::Toolkit::TableView *)jarg1;
75785   argp2 = (Dali::Actor *)jarg2;
75786   if (!argp2) {
75787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75788     return 0;
75789   }
75790   arg2 = *argp2;
75791   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
75792   if (!argp3) {
75793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75794     return 0;
75795   }
75796   arg3 = *argp3;
75797   {
75798     try {
75799       result = (bool)(arg1)->AddChild(arg2,arg3);
75800     } catch (std::out_of_range& e) {
75801       {
75802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75803       };
75804     } catch (std::exception& e) {
75805       {
75806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75807       };
75808     } catch (...) {
75809       {
75810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75811       };
75812     }
75813   }
75814   jresult = result;
75815   return jresult;
75816 }
75817
75818
75819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
75820   void * jresult ;
75821   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75822   Dali::Toolkit::TableView::CellPosition arg2 ;
75823   Dali::Toolkit::TableView::CellPosition *argp2 ;
75824   Dali::Actor result;
75825
75826   arg1 = (Dali::Toolkit::TableView *)jarg1;
75827   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
75828   if (!argp2) {
75829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75830     return 0;
75831   }
75832   arg2 = *argp2;
75833   {
75834     try {
75835       result = (arg1)->GetChildAt(arg2);
75836     } catch (std::out_of_range& e) {
75837       {
75838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75839       };
75840     } catch (std::exception& e) {
75841       {
75842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75843       };
75844     } catch (...) {
75845       {
75846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75847       };
75848     }
75849   }
75850   jresult = new Dali::Actor((const Dali::Actor &)result);
75851   return jresult;
75852 }
75853
75854
75855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
75856   void * jresult ;
75857   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75858   Dali::Toolkit::TableView::CellPosition arg2 ;
75859   Dali::Toolkit::TableView::CellPosition *argp2 ;
75860   Dali::Actor result;
75861
75862   arg1 = (Dali::Toolkit::TableView *)jarg1;
75863   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
75864   if (!argp2) {
75865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75866     return 0;
75867   }
75868   arg2 = *argp2;
75869   {
75870     try {
75871       result = (arg1)->RemoveChildAt(arg2);
75872     } catch (std::out_of_range& e) {
75873       {
75874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75875       };
75876     } catch (std::exception& e) {
75877       {
75878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75879       };
75880     } catch (...) {
75881       {
75882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75883       };
75884     }
75885   }
75886   jresult = new Dali::Actor((const Dali::Actor &)result);
75887   return jresult;
75888 }
75889
75890
75891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
75892   unsigned int jresult ;
75893   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75894   Dali::Actor arg2 ;
75895   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
75896   Dali::Actor *argp2 ;
75897   bool result;
75898
75899   arg1 = (Dali::Toolkit::TableView *)jarg1;
75900   argp2 = (Dali::Actor *)jarg2;
75901   if (!argp2) {
75902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75903     return 0;
75904   }
75905   arg2 = *argp2;
75906   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
75907   if (!arg3) {
75908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
75909     return 0;
75910   }
75911   {
75912     try {
75913       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
75914     } catch (std::out_of_range& e) {
75915       {
75916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75917       };
75918     } catch (std::exception& e) {
75919       {
75920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75921       };
75922     } catch (...) {
75923       {
75924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75925       };
75926     }
75927   }
75928   jresult = result;
75929   return jresult;
75930 }
75931
75932
75933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
75934   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75935   unsigned int arg2 ;
75936
75937   arg1 = (Dali::Toolkit::TableView *)jarg1;
75938   arg2 = (unsigned int)jarg2;
75939   {
75940     try {
75941       (arg1)->InsertRow(arg2);
75942     } catch (std::out_of_range& e) {
75943       {
75944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75945       };
75946     } catch (std::exception& e) {
75947       {
75948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75949       };
75950     } catch (...) {
75951       {
75952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75953       };
75954     }
75955   }
75956 }
75957
75958
75959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
75960   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75961   unsigned int arg2 ;
75962
75963   arg1 = (Dali::Toolkit::TableView *)jarg1;
75964   arg2 = (unsigned int)jarg2;
75965   {
75966     try {
75967       (arg1)->DeleteRow(arg2);
75968     } catch (std::out_of_range& e) {
75969       {
75970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75971       };
75972     } catch (std::exception& e) {
75973       {
75974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75975       };
75976     } catch (...) {
75977       {
75978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75979       };
75980     }
75981   }
75982 }
75983
75984
75985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
75986   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75987   unsigned int arg2 ;
75988   std::vector< Dali::Actor > *arg3 = 0 ;
75989
75990   arg1 = (Dali::Toolkit::TableView *)jarg1;
75991   arg2 = (unsigned int)jarg2;
75992   arg3 = (std::vector< Dali::Actor > *)jarg3;
75993   if (!arg3) {
75994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
75995     return ;
75996   }
75997   {
75998     try {
75999       (arg1)->DeleteRow(arg2,*arg3);
76000     } catch (std::out_of_range& e) {
76001       {
76002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76003       };
76004     } catch (std::exception& e) {
76005       {
76006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76007       };
76008     } catch (...) {
76009       {
76010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76011       };
76012     }
76013   }
76014 }
76015
76016
76017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
76018   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76019   unsigned int arg2 ;
76020
76021   arg1 = (Dali::Toolkit::TableView *)jarg1;
76022   arg2 = (unsigned int)jarg2;
76023   {
76024     try {
76025       (arg1)->InsertColumn(arg2);
76026     } catch (std::out_of_range& e) {
76027       {
76028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76029       };
76030     } catch (std::exception& e) {
76031       {
76032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76033       };
76034     } catch (...) {
76035       {
76036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76037       };
76038     }
76039   }
76040 }
76041
76042
76043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
76044   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76045   unsigned int arg2 ;
76046
76047   arg1 = (Dali::Toolkit::TableView *)jarg1;
76048   arg2 = (unsigned int)jarg2;
76049   {
76050     try {
76051       (arg1)->DeleteColumn(arg2);
76052     } catch (std::out_of_range& e) {
76053       {
76054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76055       };
76056     } catch (std::exception& e) {
76057       {
76058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76059       };
76060     } catch (...) {
76061       {
76062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76063       };
76064     }
76065   }
76066 }
76067
76068
76069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
76070   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76071   unsigned int arg2 ;
76072   std::vector< Dali::Actor > *arg3 = 0 ;
76073
76074   arg1 = (Dali::Toolkit::TableView *)jarg1;
76075   arg2 = (unsigned int)jarg2;
76076   arg3 = (std::vector< Dali::Actor > *)jarg3;
76077   if (!arg3) {
76078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76079     return ;
76080   }
76081   {
76082     try {
76083       (arg1)->DeleteColumn(arg2,*arg3);
76084     } catch (std::out_of_range& e) {
76085       {
76086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76087       };
76088     } catch (std::exception& e) {
76089       {
76090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76091       };
76092     } catch (...) {
76093       {
76094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76095       };
76096     }
76097   }
76098 }
76099
76100
76101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
76102   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76103   unsigned int arg2 ;
76104   unsigned int arg3 ;
76105
76106   arg1 = (Dali::Toolkit::TableView *)jarg1;
76107   arg2 = (unsigned int)jarg2;
76108   arg3 = (unsigned int)jarg3;
76109   {
76110     try {
76111       (arg1)->Resize(arg2,arg3);
76112     } catch (std::out_of_range& e) {
76113       {
76114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76115       };
76116     } catch (std::exception& e) {
76117       {
76118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76119       };
76120     } catch (...) {
76121       {
76122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76123       };
76124     }
76125   }
76126 }
76127
76128
76129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
76130   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76131   unsigned int arg2 ;
76132   unsigned int arg3 ;
76133   std::vector< Dali::Actor > *arg4 = 0 ;
76134
76135   arg1 = (Dali::Toolkit::TableView *)jarg1;
76136   arg2 = (unsigned int)jarg2;
76137   arg3 = (unsigned int)jarg3;
76138   arg4 = (std::vector< Dali::Actor > *)jarg4;
76139   if (!arg4) {
76140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76141     return ;
76142   }
76143   {
76144     try {
76145       (arg1)->Resize(arg2,arg3,*arg4);
76146     } catch (std::out_of_range& e) {
76147       {
76148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76149       };
76150     } catch (std::exception& e) {
76151       {
76152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76153       };
76154     } catch (...) {
76155       {
76156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76157       };
76158     }
76159   }
76160 }
76161
76162
76163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
76164   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76165   Dali::Size arg2 ;
76166   Dali::Size *argp2 ;
76167
76168   arg1 = (Dali::Toolkit::TableView *)jarg1;
76169   argp2 = (Dali::Size *)jarg2;
76170   if (!argp2) {
76171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
76172     return ;
76173   }
76174   arg2 = *argp2;
76175   {
76176     try {
76177       (arg1)->SetCellPadding(arg2);
76178     } catch (std::out_of_range& e) {
76179       {
76180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76181       };
76182     } catch (std::exception& e) {
76183       {
76184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76185       };
76186     } catch (...) {
76187       {
76188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76189       };
76190     }
76191   }
76192 }
76193
76194
76195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
76196   void * jresult ;
76197   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76198   Dali::Size result;
76199
76200   arg1 = (Dali::Toolkit::TableView *)jarg1;
76201   {
76202     try {
76203       result = (arg1)->GetCellPadding();
76204     } catch (std::out_of_range& e) {
76205       {
76206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76207       };
76208     } catch (std::exception& e) {
76209       {
76210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76211       };
76212     } catch (...) {
76213       {
76214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76215       };
76216     }
76217   }
76218   jresult = new Dali::Size((const Dali::Size &)result);
76219   return jresult;
76220 }
76221
76222
76223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
76224   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76225   unsigned int arg2 ;
76226
76227   arg1 = (Dali::Toolkit::TableView *)jarg1;
76228   arg2 = (unsigned int)jarg2;
76229   {
76230     try {
76231       (arg1)->SetFitHeight(arg2);
76232     } catch (std::out_of_range& e) {
76233       {
76234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76235       };
76236     } catch (std::exception& e) {
76237       {
76238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76239       };
76240     } catch (...) {
76241       {
76242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76243       };
76244     }
76245   }
76246 }
76247
76248
76249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
76250   unsigned int jresult ;
76251   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76252   unsigned int arg2 ;
76253   bool result;
76254
76255   arg1 = (Dali::Toolkit::TableView *)jarg1;
76256   arg2 = (unsigned int)jarg2;
76257   {
76258     try {
76259       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
76260     } catch (std::out_of_range& e) {
76261       {
76262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76263       };
76264     } catch (std::exception& e) {
76265       {
76266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76267       };
76268     } catch (...) {
76269       {
76270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76271       };
76272     }
76273   }
76274   jresult = result;
76275   return jresult;
76276 }
76277
76278
76279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
76280   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76281   unsigned int arg2 ;
76282
76283   arg1 = (Dali::Toolkit::TableView *)jarg1;
76284   arg2 = (unsigned int)jarg2;
76285   {
76286     try {
76287       (arg1)->SetFitWidth(arg2);
76288     } catch (std::out_of_range& e) {
76289       {
76290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76291       };
76292     } catch (std::exception& e) {
76293       {
76294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76295       };
76296     } catch (...) {
76297       {
76298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76299       };
76300     }
76301   }
76302 }
76303
76304
76305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
76306   unsigned int jresult ;
76307   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76308   unsigned int arg2 ;
76309   bool result;
76310
76311   arg1 = (Dali::Toolkit::TableView *)jarg1;
76312   arg2 = (unsigned int)jarg2;
76313   {
76314     try {
76315       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
76316     } catch (std::out_of_range& e) {
76317       {
76318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76319       };
76320     } catch (std::exception& e) {
76321       {
76322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76323       };
76324     } catch (...) {
76325       {
76326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76327       };
76328     }
76329   }
76330   jresult = result;
76331   return jresult;
76332 }
76333
76334
76335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
76336   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76337   unsigned int arg2 ;
76338   float arg3 ;
76339
76340   arg1 = (Dali::Toolkit::TableView *)jarg1;
76341   arg2 = (unsigned int)jarg2;
76342   arg3 = (float)jarg3;
76343   {
76344     try {
76345       (arg1)->SetFixedHeight(arg2,arg3);
76346     } catch (std::out_of_range& e) {
76347       {
76348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76349       };
76350     } catch (std::exception& e) {
76351       {
76352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76353       };
76354     } catch (...) {
76355       {
76356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76357       };
76358     }
76359   }
76360 }
76361
76362
76363 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
76364   float jresult ;
76365   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76366   unsigned int arg2 ;
76367   float result;
76368
76369   arg1 = (Dali::Toolkit::TableView *)jarg1;
76370   arg2 = (unsigned int)jarg2;
76371   {
76372     try {
76373       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
76374     } catch (std::out_of_range& e) {
76375       {
76376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76377       };
76378     } catch (std::exception& e) {
76379       {
76380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76381       };
76382     } catch (...) {
76383       {
76384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76385       };
76386     }
76387   }
76388   jresult = result;
76389   return jresult;
76390 }
76391
76392
76393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
76394   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76395   unsigned int arg2 ;
76396   float arg3 ;
76397
76398   arg1 = (Dali::Toolkit::TableView *)jarg1;
76399   arg2 = (unsigned int)jarg2;
76400   arg3 = (float)jarg3;
76401   {
76402     try {
76403       (arg1)->SetRelativeHeight(arg2,arg3);
76404     } catch (std::out_of_range& e) {
76405       {
76406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76407       };
76408     } catch (std::exception& e) {
76409       {
76410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76411       };
76412     } catch (...) {
76413       {
76414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76415       };
76416     }
76417   }
76418 }
76419
76420
76421 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
76422   float jresult ;
76423   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76424   unsigned int arg2 ;
76425   float result;
76426
76427   arg1 = (Dali::Toolkit::TableView *)jarg1;
76428   arg2 = (unsigned int)jarg2;
76429   {
76430     try {
76431       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
76432     } catch (std::out_of_range& e) {
76433       {
76434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76435       };
76436     } catch (std::exception& e) {
76437       {
76438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76439       };
76440     } catch (...) {
76441       {
76442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76443       };
76444     }
76445   }
76446   jresult = result;
76447   return jresult;
76448 }
76449
76450
76451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
76452   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76453   unsigned int arg2 ;
76454   float arg3 ;
76455
76456   arg1 = (Dali::Toolkit::TableView *)jarg1;
76457   arg2 = (unsigned int)jarg2;
76458   arg3 = (float)jarg3;
76459   {
76460     try {
76461       (arg1)->SetFixedWidth(arg2,arg3);
76462     } catch (std::out_of_range& e) {
76463       {
76464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76465       };
76466     } catch (std::exception& e) {
76467       {
76468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76469       };
76470     } catch (...) {
76471       {
76472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76473       };
76474     }
76475   }
76476 }
76477
76478
76479 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
76480   float jresult ;
76481   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76482   unsigned int arg2 ;
76483   float result;
76484
76485   arg1 = (Dali::Toolkit::TableView *)jarg1;
76486   arg2 = (unsigned int)jarg2;
76487   {
76488     try {
76489       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
76490     } catch (std::out_of_range& e) {
76491       {
76492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76493       };
76494     } catch (std::exception& e) {
76495       {
76496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76497       };
76498     } catch (...) {
76499       {
76500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76501       };
76502     }
76503   }
76504   jresult = result;
76505   return jresult;
76506 }
76507
76508
76509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
76510   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76511   unsigned int arg2 ;
76512   float arg3 ;
76513
76514   arg1 = (Dali::Toolkit::TableView *)jarg1;
76515   arg2 = (unsigned int)jarg2;
76516   arg3 = (float)jarg3;
76517   {
76518     try {
76519       (arg1)->SetRelativeWidth(arg2,arg3);
76520     } catch (std::out_of_range& e) {
76521       {
76522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76523       };
76524     } catch (std::exception& e) {
76525       {
76526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76527       };
76528     } catch (...) {
76529       {
76530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76531       };
76532     }
76533   }
76534 }
76535
76536
76537 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
76538   float jresult ;
76539   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76540   unsigned int arg2 ;
76541   float result;
76542
76543   arg1 = (Dali::Toolkit::TableView *)jarg1;
76544   arg2 = (unsigned int)jarg2;
76545   {
76546     try {
76547       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
76548     } catch (std::out_of_range& e) {
76549       {
76550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76551       };
76552     } catch (std::exception& e) {
76553       {
76554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76555       };
76556     } catch (...) {
76557       {
76558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76559       };
76560     }
76561   }
76562   jresult = result;
76563   return jresult;
76564 }
76565
76566
76567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
76568   unsigned int jresult ;
76569   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76570   unsigned int result;
76571
76572   arg1 = (Dali::Toolkit::TableView *)jarg1;
76573   {
76574     try {
76575       result = (unsigned int)(arg1)->GetRows();
76576     } catch (std::out_of_range& e) {
76577       {
76578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76579       };
76580     } catch (std::exception& e) {
76581       {
76582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76583       };
76584     } catch (...) {
76585       {
76586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76587       };
76588     }
76589   }
76590   jresult = result;
76591   return jresult;
76592 }
76593
76594
76595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
76596   unsigned int jresult ;
76597   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76598   unsigned int result;
76599
76600   arg1 = (Dali::Toolkit::TableView *)jarg1;
76601   {
76602     try {
76603       result = (unsigned int)(arg1)->GetColumns();
76604     } catch (std::out_of_range& e) {
76605       {
76606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76607       };
76608     } catch (std::exception& e) {
76609       {
76610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76611       };
76612     } catch (...) {
76613       {
76614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76615       };
76616     }
76617   }
76618   jresult = result;
76619   return jresult;
76620 }
76621
76622
76623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
76624   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76625   Dali::Toolkit::TableView::CellPosition arg2 ;
76626   Dali::HorizontalAlignment::Type arg3 ;
76627   Dali::VerticalAlignment::Type arg4 ;
76628   Dali::Toolkit::TableView::CellPosition *argp2 ;
76629
76630   arg1 = (Dali::Toolkit::TableView *)jarg1;
76631   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76632   if (!argp2) {
76633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76634     return ;
76635   }
76636   arg2 = *argp2;
76637   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
76638   arg4 = (Dali::VerticalAlignment::Type)jarg4;
76639   {
76640     try {
76641       (arg1)->SetCellAlignment(arg2,arg3,arg4);
76642     } catch (std::out_of_range& e) {
76643       {
76644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76645       };
76646     } catch (std::exception& e) {
76647       {
76648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76649       };
76650     } catch (...) {
76651       {
76652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76653       };
76654     }
76655   }
76656 }
76657
76658
76659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
76660   unsigned int jresult ;
76661   unsigned int result;
76662
76663   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
76664   jresult = result;
76665   return jresult;
76666 }
76667
76668
76669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() {
76670   int jresult ;
76671   int result;
76672
76673   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
76674   jresult = (int)result;
76675   return jresult;
76676 }
76677
76678
76679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() {
76680   int jresult ;
76681   int result;
76682
76683   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
76684   jresult = (int)result;
76685   return jresult;
76686 }
76687
76688
76689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() {
76690   int jresult ;
76691   int result;
76692
76693   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
76694   jresult = (int)result;
76695   return jresult;
76696 }
76697
76698
76699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() {
76700   int jresult ;
76701   int result;
76702
76703   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
76704   jresult = (int)result;
76705   return jresult;
76706 }
76707
76708
76709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() {
76710   int jresult ;
76711   int result;
76712
76713   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
76714   jresult = (int)result;
76715   return jresult;
76716 }
76717
76718
76719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() {
76720   int jresult ;
76721   int result;
76722
76723   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
76724   jresult = (int)result;
76725   return jresult;
76726 }
76727
76728
76729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
76730   int jresult ;
76731   int result;
76732
76733   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
76734   jresult = (int)result;
76735   return jresult;
76736 }
76737
76738
76739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() {
76740   int jresult ;
76741   int result;
76742
76743   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
76744   jresult = (int)result;
76745   return jresult;
76746 }
76747
76748
76749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() {
76750   int jresult ;
76751   int result;
76752
76753   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
76754   jresult = (int)result;
76755   return jresult;
76756 }
76757
76758
76759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
76760   int jresult ;
76761   int result;
76762
76763   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
76764   jresult = (int)result;
76765   return jresult;
76766 }
76767
76768
76769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
76770   int jresult ;
76771   int result;
76772
76773   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
76774   jresult = (int)result;
76775   return jresult;
76776 }
76777
76778
76779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
76780   int jresult ;
76781   int result;
76782
76783   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
76784   jresult = (int)result;
76785   return jresult;
76786 }
76787
76788
76789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
76790   int jresult ;
76791   int result;
76792
76793   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
76794   jresult = (int)result;
76795   return jresult;
76796 }
76797
76798
76799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
76800   int jresult ;
76801   int result;
76802
76803   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
76804   jresult = (int)result;
76805   return jresult;
76806 }
76807
76808
76809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() {
76810   int jresult ;
76811   int result;
76812
76813   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
76814   jresult = (int)result;
76815   return jresult;
76816 }
76817
76818
76819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
76820   int jresult ;
76821   int result;
76822
76823   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
76824   jresult = (int)result;
76825   return jresult;
76826 }
76827
76828
76829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
76830   int jresult ;
76831   int result;
76832
76833   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
76834   jresult = (int)result;
76835   return jresult;
76836 }
76837
76838
76839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
76840   int jresult ;
76841   int result;
76842
76843   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
76844   jresult = (int)result;
76845   return jresult;
76846 }
76847
76848
76849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
76850   int jresult ;
76851   int result;
76852
76853   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
76854   jresult = (int)result;
76855   return jresult;
76856 }
76857
76858
76859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
76860   int jresult ;
76861   int result;
76862
76863   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
76864   jresult = (int)result;
76865   return jresult;
76866 }
76867
76868
76869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
76870   int jresult ;
76871   int result;
76872
76873   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
76874   jresult = (int)result;
76875   return jresult;
76876 }
76877
76878
76879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
76880   int jresult ;
76881   int result;
76882
76883   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
76884   jresult = (int)result;
76885   return jresult;
76886 }
76887
76888
76889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
76890   int jresult ;
76891   int result;
76892
76893   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
76894   jresult = (int)result;
76895   return jresult;
76896 }
76897
76898
76899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
76900   int jresult ;
76901   int result;
76902
76903   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
76904   jresult = (int)result;
76905   return jresult;
76906 }
76907
76908
76909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
76910   int jresult ;
76911   int result;
76912
76913   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
76914   jresult = (int)result;
76915   return jresult;
76916 }
76917
76918
76919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() {
76920   int jresult ;
76921   int result;
76922
76923   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
76924   jresult = (int)result;
76925   return jresult;
76926 }
76927
76928
76929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() {
76930   int jresult ;
76931   int result;
76932
76933   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
76934   jresult = (int)result;
76935   return jresult;
76936 }
76937
76938
76939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() {
76940   int jresult ;
76941   int result;
76942
76943   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
76944   jresult = (int)result;
76945   return jresult;
76946 }
76947
76948
76949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() {
76950   int jresult ;
76951   int result;
76952
76953   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
76954   jresult = (int)result;
76955   return jresult;
76956 }
76957
76958
76959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() {
76960   int jresult ;
76961   int result;
76962
76963   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
76964   jresult = (int)result;
76965   return jresult;
76966 }
76967
76968
76969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() {
76970   int jresult ;
76971   int result;
76972
76973   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
76974   jresult = (int)result;
76975   return jresult;
76976 }
76977
76978
76979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() {
76980   int jresult ;
76981   int result;
76982
76983   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
76984   jresult = (int)result;
76985   return jresult;
76986 }
76987
76988
76989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() {
76990   int jresult ;
76991   int result;
76992
76993   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
76994   jresult = (int)result;
76995   return jresult;
76996 }
76997
76998
76999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() {
77000   int jresult ;
77001   int result;
77002
77003   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
77004   jresult = (int)result;
77005   return jresult;
77006 }
77007
77008
77009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() {
77010   int jresult ;
77011   int result;
77012
77013   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
77014   jresult = (int)result;
77015   return jresult;
77016 }
77017
77018
77019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() {
77020   int jresult ;
77021   int result;
77022
77023   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
77024   jresult = (int)result;
77025   return jresult;
77026 }
77027
77028
77029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() {
77030   int jresult ;
77031   int result;
77032
77033   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
77034   jresult = (int)result;
77035   return jresult;
77036 }
77037
77038
77039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() {
77040   int jresult ;
77041   int result;
77042
77043   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
77044   jresult = (int)result;
77045   return jresult;
77046 }
77047
77048
77049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() {
77050   int jresult ;
77051   int result;
77052
77053   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
77054   jresult = (int)result;
77055   return jresult;
77056 }
77057
77058
77059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() {
77060   int jresult ;
77061   int result;
77062
77063   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
77064   jresult = (int)result;
77065   return jresult;
77066 }
77067
77068
77069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() {
77070   void * jresult ;
77071   Dali::Toolkit::TextEditor::Property *result = 0 ;
77072
77073   {
77074     try {
77075       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
77076     } catch (std::out_of_range& e) {
77077       {
77078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77079       };
77080     } catch (std::exception& e) {
77081       {
77082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77083       };
77084     } catch (...) {
77085       {
77086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77087       };
77088     }
77089   }
77090   jresult = (void *)result;
77091   return jresult;
77092 }
77093
77094
77095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) {
77096   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
77097
77098   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
77099   {
77100     try {
77101       delete arg1;
77102     } catch (std::out_of_range& e) {
77103       {
77104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77105       };
77106     } catch (std::exception& e) {
77107       {
77108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77109       };
77110     } catch (...) {
77111       {
77112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77113       };
77114     }
77115   }
77116 }
77117
77118
77119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() {
77120   void * jresult ;
77121   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
77122
77123   {
77124     try {
77125       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
77126     } catch (std::out_of_range& e) {
77127       {
77128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77129       };
77130     } catch (std::exception& e) {
77131       {
77132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77133       };
77134     } catch (...) {
77135       {
77136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77137       };
77138     }
77139   }
77140   jresult = (void *)result;
77141   return jresult;
77142 }
77143
77144
77145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) {
77146   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
77147
77148   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
77149   {
77150     try {
77151       delete arg1;
77152     } catch (std::out_of_range& e) {
77153       {
77154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77155       };
77156     } catch (std::exception& e) {
77157       {
77158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77159       };
77160     } catch (...) {
77161       {
77162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77163       };
77164     }
77165   }
77166 }
77167
77168
77169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() {
77170   void * jresult ;
77171   Dali::Toolkit::TextEditor result;
77172
77173   {
77174     try {
77175       result = Dali::Toolkit::TextEditor::New();
77176     } catch (std::out_of_range& e) {
77177       {
77178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77179       };
77180     } catch (std::exception& e) {
77181       {
77182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77183       };
77184     } catch (...) {
77185       {
77186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77187       };
77188     }
77189   }
77190   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
77191   return jresult;
77192 }
77193
77194
77195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() {
77196   void * jresult ;
77197   Dali::Toolkit::TextEditor *result = 0 ;
77198
77199   {
77200     try {
77201       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
77202     } catch (std::out_of_range& e) {
77203       {
77204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77205       };
77206     } catch (std::exception& e) {
77207       {
77208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77209       };
77210     } catch (...) {
77211       {
77212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77213       };
77214     }
77215   }
77216   jresult = (void *)result;
77217   return jresult;
77218 }
77219
77220
77221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) {
77222   void * jresult ;
77223   Dali::Toolkit::TextEditor *arg1 = 0 ;
77224   Dali::Toolkit::TextEditor *result = 0 ;
77225
77226   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77227   if (!arg1) {
77228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77229     return 0;
77230   }
77231   {
77232     try {
77233       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
77234     } catch (std::out_of_range& e) {
77235       {
77236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77237       };
77238     } catch (std::exception& e) {
77239       {
77240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77241       };
77242     } catch (...) {
77243       {
77244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77245       };
77246     }
77247   }
77248   jresult = (void *)result;
77249   return jresult;
77250 }
77251
77252
77253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) {
77254   void * jresult ;
77255   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77256   Dali::Toolkit::TextEditor *arg2 = 0 ;
77257   Dali::Toolkit::TextEditor *result = 0 ;
77258
77259   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77260   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
77261   if (!arg2) {
77262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77263     return 0;
77264   }
77265   {
77266     try {
77267       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
77268     } catch (std::out_of_range& e) {
77269       {
77270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77271       };
77272     } catch (std::exception& e) {
77273       {
77274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77275       };
77276     } catch (...) {
77277       {
77278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77279       };
77280     }
77281   }
77282   jresult = (void *)result;
77283   return jresult;
77284 }
77285
77286
77287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) {
77288   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77289
77290   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77291   {
77292     try {
77293       delete arg1;
77294     } catch (std::out_of_range& e) {
77295       {
77296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77297       };
77298     } catch (std::exception& e) {
77299       {
77300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77301       };
77302     } catch (...) {
77303       {
77304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77305       };
77306     }
77307   }
77308 }
77309
77310
77311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) {
77312   void * jresult ;
77313   Dali::BaseHandle arg1 ;
77314   Dali::BaseHandle *argp1 ;
77315   Dali::Toolkit::TextEditor result;
77316
77317   argp1 = (Dali::BaseHandle *)jarg1;
77318   if (!argp1) {
77319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77320     return 0;
77321   }
77322   arg1 = *argp1;
77323   {
77324     try {
77325       result = Dali::Toolkit::TextEditor::DownCast(arg1);
77326     } catch (std::out_of_range& e) {
77327       {
77328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77329       };
77330     } catch (std::exception& e) {
77331       {
77332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77333       };
77334     } catch (...) {
77335       {
77336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77337       };
77338     }
77339   }
77340   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
77341   return jresult;
77342 }
77343
77344
77345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) {
77346   void * jresult ;
77347   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77348   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
77349
77350   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77351   {
77352     try {
77353       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
77354     } catch (std::out_of_range& e) {
77355       {
77356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77357       };
77358     } catch (std::exception& e) {
77359       {
77360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77361       };
77362     } catch (...) {
77363       {
77364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77365       };
77366     }
77367   }
77368   jresult = (void *)result;
77369   return jresult;
77370 }
77371
77372
77373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) {
77374   void * jresult ;
77375   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77376   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
77377
77378   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77379   {
77380     try {
77381       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
77382     } catch (std::out_of_range& e) {
77383       {
77384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77385       };
77386     } catch (std::exception& e) {
77387       {
77388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77389       };
77390     } catch (...) {
77391       {
77392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77393       };
77394     }
77395   }
77396   jresult = (void *)result;
77397   return jresult;
77398 }
77399
77400
77401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() {
77402   int jresult ;
77403   int result;
77404
77405   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
77406   jresult = (int)result;
77407   return jresult;
77408 }
77409
77410
77411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() {
77412   int jresult ;
77413   int result;
77414
77415   result = (int)Dali::Toolkit::TextField::Property::TEXT;
77416   jresult = (int)result;
77417   return jresult;
77418 }
77419
77420
77421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() {
77422   int jresult ;
77423   int result;
77424
77425   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
77426   jresult = (int)result;
77427   return jresult;
77428 }
77429
77430
77431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
77432   int jresult ;
77433   int result;
77434
77435   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
77436   jresult = (int)result;
77437   return jresult;
77438 }
77439
77440
77441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() {
77442   int jresult ;
77443   int result;
77444
77445   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
77446   jresult = (int)result;
77447   return jresult;
77448 }
77449
77450
77451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() {
77452   int jresult ;
77453   int result;
77454
77455   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
77456   jresult = (int)result;
77457   return jresult;
77458 }
77459
77460
77461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() {
77462   int jresult ;
77463   int result;
77464
77465   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
77466   jresult = (int)result;
77467   return jresult;
77468 }
77469
77470
77471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() {
77472   int jresult ;
77473   int result;
77474
77475   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
77476   jresult = (int)result;
77477   return jresult;
77478 }
77479
77480
77481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() {
77482   int jresult ;
77483   int result;
77484
77485   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
77486   jresult = (int)result;
77487   return jresult;
77488 }
77489
77490
77491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
77492   int jresult ;
77493   int result;
77494
77495   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
77496   jresult = (int)result;
77497   return jresult;
77498 }
77499
77500
77501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() {
77502   int jresult ;
77503   int result;
77504
77505   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
77506   jresult = (int)result;
77507   return jresult;
77508 }
77509
77510
77511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() {
77512   int jresult ;
77513   int result;
77514
77515   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
77516   jresult = (int)result;
77517   return jresult;
77518 }
77519
77520
77521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
77522   int jresult ;
77523   int result;
77524
77525   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
77526   jresult = (int)result;
77527   return jresult;
77528 }
77529
77530
77531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_OFFSET_get() {
77532   int jresult ;
77533   int result;
77534
77535   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
77536   jresult = (int)result;
77537   return jresult;
77538 }
77539
77540
77541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_COLOR_get() {
77542   int jresult ;
77543   int result;
77544
77545   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
77546   jresult = (int)result;
77547   return jresult;
77548 }
77549
77550
77551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
77552   int jresult ;
77553   int result;
77554
77555   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
77556   jresult = (int)result;
77557   return jresult;
77558 }
77559
77560
77561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
77562   int jresult ;
77563   int result;
77564
77565   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
77566   jresult = (int)result;
77567   return jresult;
77568 }
77569
77570
77571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() {
77572   int jresult ;
77573   int result;
77574
77575   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
77576   jresult = (int)result;
77577   return jresult;
77578 }
77579
77580
77581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
77582   int jresult ;
77583   int result;
77584
77585   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
77586   jresult = (int)result;
77587   return jresult;
77588 }
77589
77590
77591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() {
77592   int jresult ;
77593   int result;
77594
77595   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
77596   jresult = (int)result;
77597   return jresult;
77598 }
77599
77600
77601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() {
77602   int jresult ;
77603   int result;
77604
77605   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
77606   jresult = (int)result;
77607   return jresult;
77608 }
77609
77610
77611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() {
77612   int jresult ;
77613   int result;
77614
77615   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
77616   jresult = (int)result;
77617   return jresult;
77618 }
77619
77620
77621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77622   int jresult ;
77623   int result;
77624
77625   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
77626   jresult = (int)result;
77627   return jresult;
77628 }
77629
77630
77631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() {
77632   int jresult ;
77633   int result;
77634
77635   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
77636   jresult = (int)result;
77637   return jresult;
77638 }
77639
77640
77641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() {
77642   int jresult ;
77643   int result;
77644
77645   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
77646   jresult = (int)result;
77647   return jresult;
77648 }
77649
77650
77651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77652   int jresult ;
77653   int result;
77654
77655   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
77656   jresult = (int)result;
77657   return jresult;
77658 }
77659
77660
77661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77662   int jresult ;
77663   int result;
77664
77665   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77666   jresult = (int)result;
77667   return jresult;
77668 }
77669
77670
77671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77672   int jresult ;
77673   int result;
77674
77675   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77676   jresult = (int)result;
77677   return jresult;
77678 }
77679
77680
77681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77682   int jresult ;
77683   int result;
77684
77685   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77686   jresult = (int)result;
77687   return jresult;
77688 }
77689
77690
77691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77692   int jresult ;
77693   int result;
77694
77695   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77696   jresult = (int)result;
77697   return jresult;
77698 }
77699
77700
77701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77702   int jresult ;
77703   int result;
77704
77705   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
77706   jresult = (int)result;
77707   return jresult;
77708 }
77709
77710
77711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77712   int jresult ;
77713   int result;
77714
77715   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
77716   jresult = (int)result;
77717   return jresult;
77718 }
77719
77720
77721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() {
77722   int jresult ;
77723   int result;
77724
77725   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
77726   jresult = (int)result;
77727   return jresult;
77728 }
77729
77730
77731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() {
77732   int jresult ;
77733   int result;
77734
77735   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
77736   jresult = (int)result;
77737   return jresult;
77738 }
77739
77740
77741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() {
77742   int jresult ;
77743   int result;
77744
77745   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
77746   jresult = (int)result;
77747   return jresult;
77748 }
77749
77750
77751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() {
77752   int jresult ;
77753   int result;
77754
77755   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
77756   jresult = (int)result;
77757   return jresult;
77758 }
77759
77760
77761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() {
77762   int jresult ;
77763   int result;
77764
77765   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
77766   jresult = (int)result;
77767   return jresult;
77768 }
77769
77770
77771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() {
77772   int jresult ;
77773   int result;
77774
77775   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
77776   jresult = (int)result;
77777   return jresult;
77778 }
77779
77780
77781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() {
77782   int jresult ;
77783   int result;
77784
77785   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
77786   jresult = (int)result;
77787   return jresult;
77788 }
77789
77790
77791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() {
77792   int jresult ;
77793   int result;
77794
77795   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
77796   jresult = (int)result;
77797   return jresult;
77798 }
77799
77800
77801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() {
77802   int jresult ;
77803   int result;
77804
77805   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
77806   jresult = (int)result;
77807   return jresult;
77808 }
77809
77810
77811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() {
77812   int jresult ;
77813   int result;
77814
77815   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
77816   jresult = (int)result;
77817   return jresult;
77818 }
77819
77820
77821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() {
77822   int jresult ;
77823   int result;
77824
77825   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
77826   jresult = (int)result;
77827   return jresult;
77828 }
77829
77830
77831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() {
77832   int jresult ;
77833   int result;
77834
77835   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
77836   jresult = (int)result;
77837   return jresult;
77838 }
77839
77840
77841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() {
77842   int jresult ;
77843   int result;
77844
77845   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
77846   jresult = (int)result;
77847   return jresult;
77848 }
77849
77850
77851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() {
77852   int jresult ;
77853   int result;
77854
77855   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
77856   jresult = (int)result;
77857   return jresult;
77858 }
77859
77860
77861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() {
77862   int jresult ;
77863   int result;
77864
77865   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
77866   jresult = (int)result;
77867   return jresult;
77868 }
77869
77870
77871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() {
77872   void * jresult ;
77873   Dali::Toolkit::TextField::Property *result = 0 ;
77874
77875   {
77876     try {
77877       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
77878     } catch (std::out_of_range& e) {
77879       {
77880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77881       };
77882     } catch (std::exception& e) {
77883       {
77884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77885       };
77886     } catch (...) {
77887       {
77888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77889       };
77890     }
77891   }
77892   jresult = (void *)result;
77893   return jresult;
77894 }
77895
77896
77897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) {
77898   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
77899
77900   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
77901   {
77902     try {
77903       delete arg1;
77904     } catch (std::out_of_range& e) {
77905       {
77906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77907       };
77908     } catch (std::exception& e) {
77909       {
77910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77911       };
77912     } catch (...) {
77913       {
77914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77915       };
77916     }
77917   }
77918 }
77919
77920
77921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() {
77922   void * jresult ;
77923   Dali::Toolkit::TextField::InputStyle *result = 0 ;
77924
77925   {
77926     try {
77927       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
77928     } catch (std::out_of_range& e) {
77929       {
77930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77931       };
77932     } catch (std::exception& e) {
77933       {
77934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77935       };
77936     } catch (...) {
77937       {
77938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77939       };
77940     }
77941   }
77942   jresult = (void *)result;
77943   return jresult;
77944 }
77945
77946
77947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) {
77948   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
77949
77950   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
77951   {
77952     try {
77953       delete arg1;
77954     } catch (std::out_of_range& e) {
77955       {
77956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77957       };
77958     } catch (std::exception& e) {
77959       {
77960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77961       };
77962     } catch (...) {
77963       {
77964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77965       };
77966     }
77967   }
77968 }
77969
77970
77971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() {
77972   void * jresult ;
77973   Dali::Toolkit::TextField result;
77974
77975   {
77976     try {
77977       result = Dali::Toolkit::TextField::New();
77978     } catch (std::out_of_range& e) {
77979       {
77980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77981       };
77982     } catch (std::exception& e) {
77983       {
77984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77985       };
77986     } catch (...) {
77987       {
77988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77989       };
77990     }
77991   }
77992   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
77993   return jresult;
77994 }
77995
77996
77997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() {
77998   void * jresult ;
77999   Dali::Toolkit::TextField *result = 0 ;
78000
78001   {
78002     try {
78003       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
78004     } catch (std::out_of_range& e) {
78005       {
78006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78007       };
78008     } catch (std::exception& e) {
78009       {
78010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78011       };
78012     } catch (...) {
78013       {
78014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78015       };
78016     }
78017   }
78018   jresult = (void *)result;
78019   return jresult;
78020 }
78021
78022
78023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) {
78024   void * jresult ;
78025   Dali::Toolkit::TextField *arg1 = 0 ;
78026   Dali::Toolkit::TextField *result = 0 ;
78027
78028   arg1 = (Dali::Toolkit::TextField *)jarg1;
78029   if (!arg1) {
78030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
78031     return 0;
78032   }
78033   {
78034     try {
78035       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
78036     } catch (std::out_of_range& e) {
78037       {
78038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78039       };
78040     } catch (std::exception& e) {
78041       {
78042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78043       };
78044     } catch (...) {
78045       {
78046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78047       };
78048     }
78049   }
78050   jresult = (void *)result;
78051   return jresult;
78052 }
78053
78054
78055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) {
78056   void * jresult ;
78057   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78058   Dali::Toolkit::TextField *arg2 = 0 ;
78059   Dali::Toolkit::TextField *result = 0 ;
78060
78061   arg1 = (Dali::Toolkit::TextField *)jarg1;
78062   arg2 = (Dali::Toolkit::TextField *)jarg2;
78063   if (!arg2) {
78064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
78065     return 0;
78066   }
78067   {
78068     try {
78069       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
78070     } catch (std::out_of_range& e) {
78071       {
78072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78073       };
78074     } catch (std::exception& e) {
78075       {
78076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78077       };
78078     } catch (...) {
78079       {
78080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78081       };
78082     }
78083   }
78084   jresult = (void *)result;
78085   return jresult;
78086 }
78087
78088
78089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) {
78090   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78091
78092   arg1 = (Dali::Toolkit::TextField *)jarg1;
78093   {
78094     try {
78095       delete arg1;
78096     } catch (std::out_of_range& e) {
78097       {
78098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78099       };
78100     } catch (std::exception& e) {
78101       {
78102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78103       };
78104     } catch (...) {
78105       {
78106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78107       };
78108     }
78109   }
78110 }
78111
78112
78113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) {
78114   void * jresult ;
78115   Dali::BaseHandle arg1 ;
78116   Dali::BaseHandle *argp1 ;
78117   Dali::Toolkit::TextField result;
78118
78119   argp1 = (Dali::BaseHandle *)jarg1;
78120   if (!argp1) {
78121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78122     return 0;
78123   }
78124   arg1 = *argp1;
78125   {
78126     try {
78127       result = Dali::Toolkit::TextField::DownCast(arg1);
78128     } catch (std::out_of_range& e) {
78129       {
78130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78131       };
78132     } catch (std::exception& e) {
78133       {
78134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78135       };
78136     } catch (...) {
78137       {
78138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78139       };
78140     }
78141   }
78142   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
78143   return jresult;
78144 }
78145
78146
78147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) {
78148   void * jresult ;
78149   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78150   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
78151
78152   arg1 = (Dali::Toolkit::TextField *)jarg1;
78153   {
78154     try {
78155       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
78156     } catch (std::out_of_range& e) {
78157       {
78158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78159       };
78160     } catch (std::exception& e) {
78161       {
78162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78163       };
78164     } catch (...) {
78165       {
78166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78167       };
78168     }
78169   }
78170   jresult = (void *)result;
78171   return jresult;
78172 }
78173
78174
78175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) {
78176   void * jresult ;
78177   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78178   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
78179
78180   arg1 = (Dali::Toolkit::TextField *)jarg1;
78181   {
78182     try {
78183       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
78184     } catch (std::out_of_range& e) {
78185       {
78186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78187       };
78188     } catch (std::exception& e) {
78189       {
78190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78191       };
78192     } catch (...) {
78193       {
78194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78195       };
78196     }
78197   }
78198   jresult = (void *)result;
78199   return jresult;
78200 }
78201
78202
78203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) {
78204   void * jresult ;
78205   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78206   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
78207
78208   arg1 = (Dali::Toolkit::TextField *)jarg1;
78209   {
78210     try {
78211       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
78212     } catch (std::out_of_range& e) {
78213       {
78214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78215       };
78216     } catch (std::exception& e) {
78217       {
78218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78219       };
78220     } catch (...) {
78221       {
78222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78223       };
78224     }
78225   }
78226   jresult = (void *)result;
78227   return jresult;
78228 }
78229
78230
78231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
78232   int jresult ;
78233   int result;
78234
78235   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
78236   jresult = (int)result;
78237   return jresult;
78238 }
78239
78240
78241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78242   int jresult ;
78243   int result;
78244
78245   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78246   jresult = (int)result;
78247   return jresult;
78248 }
78249
78250
78251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78252   int jresult ;
78253   int result;
78254
78255   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78256   jresult = (int)result;
78257   return jresult;
78258 }
78259
78260
78261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78262   int jresult ;
78263   int result;
78264
78265   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78266   jresult = (int)result;
78267   return jresult;
78268 }
78269
78270
78271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78272   int jresult ;
78273   int result;
78274
78275   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78276   jresult = (int)result;
78277   return jresult;
78278 }
78279
78280
78281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78282   int jresult ;
78283   int result;
78284
78285   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78286   jresult = (int)result;
78287   return jresult;
78288 }
78289
78290
78291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78292   int jresult ;
78293   int result;
78294
78295   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78296   jresult = (int)result;
78297   return jresult;
78298 }
78299
78300
78301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78302   int jresult ;
78303   int result;
78304
78305   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78306   jresult = (int)result;
78307   return jresult;
78308 }
78309
78310
78311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78312   int jresult ;
78313   int result;
78314
78315   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78316   jresult = (int)result;
78317   return jresult;
78318 }
78319
78320
78321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
78322   int jresult ;
78323   int result;
78324
78325   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
78326   jresult = (int)result;
78327   return jresult;
78328 }
78329
78330
78331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
78332   int jresult ;
78333   int result;
78334
78335   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
78336   jresult = (int)result;
78337   return jresult;
78338 }
78339
78340
78341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
78342   int jresult ;
78343   int result;
78344
78345   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
78346   jresult = (int)result;
78347   return jresult;
78348 }
78349
78350
78351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
78352   int jresult ;
78353   int result;
78354
78355   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
78356   jresult = (int)result;
78357   return jresult;
78358 }
78359
78360
78361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
78362   int jresult ;
78363   int result;
78364
78365   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
78366   jresult = (int)result;
78367   return jresult;
78368 }
78369
78370
78371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78372   int jresult ;
78373   int result;
78374
78375   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78376   jresult = (int)result;
78377   return jresult;
78378 }
78379
78380
78381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78382   int jresult ;
78383   int result;
78384
78385   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78386   jresult = (int)result;
78387   return jresult;
78388 }
78389
78390
78391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78392   int jresult ;
78393   int result;
78394
78395   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78396   jresult = (int)result;
78397   return jresult;
78398 }
78399
78400
78401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78402   int jresult ;
78403   int result;
78404
78405   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78406   jresult = (int)result;
78407   return jresult;
78408 }
78409
78410
78411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78412   int jresult ;
78413   int result;
78414
78415   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78416   jresult = (int)result;
78417   return jresult;
78418 }
78419
78420
78421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78422   int jresult ;
78423   int result;
78424
78425   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78426   jresult = (int)result;
78427   return jresult;
78428 }
78429
78430
78431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78432   int jresult ;
78433   int result;
78434
78435   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78436   jresult = (int)result;
78437   return jresult;
78438 }
78439
78440
78441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78442   int jresult ;
78443   int result;
78444
78445   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78446   jresult = (int)result;
78447   return jresult;
78448 }
78449
78450
78451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78452   int jresult ;
78453   int result;
78454
78455   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78456   jresult = (int)result;
78457   return jresult;
78458 }
78459
78460
78461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78462   int jresult ;
78463   int result;
78464
78465   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78466   jresult = (int)result;
78467   return jresult;
78468 }
78469
78470
78471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78472   void * jresult ;
78473   Dali::Toolkit::TextLabel::Property *result = 0 ;
78474
78475   {
78476     try {
78477       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78478     } catch (std::out_of_range& e) {
78479       {
78480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78481       };
78482     } catch (std::exception& e) {
78483       {
78484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78485       };
78486     } catch (...) {
78487       {
78488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78489       };
78490     }
78491   }
78492   jresult = (void *)result;
78493   return jresult;
78494 }
78495
78496
78497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78498   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78499
78500   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78501   {
78502     try {
78503       delete arg1;
78504     } catch (std::out_of_range& e) {
78505       {
78506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78507       };
78508     } catch (std::exception& e) {
78509       {
78510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78511       };
78512     } catch (...) {
78513       {
78514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78515       };
78516     }
78517   }
78518 }
78519
78520
78521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78522   void * jresult ;
78523   Dali::Toolkit::TextLabel result;
78524
78525   {
78526     try {
78527       result = Dali::Toolkit::TextLabel::New();
78528     } catch (std::out_of_range& e) {
78529       {
78530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78531       };
78532     } catch (std::exception& e) {
78533       {
78534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78535       };
78536     } catch (...) {
78537       {
78538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78539       };
78540     }
78541   }
78542   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78543   return jresult;
78544 }
78545
78546
78547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78548   void * jresult ;
78549   std::string *arg1 = 0 ;
78550   Dali::Toolkit::TextLabel result;
78551
78552   if (!jarg1) {
78553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78554     return 0;
78555   }
78556   std::string arg1_str(jarg1);
78557   arg1 = &arg1_str;
78558   {
78559     try {
78560       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
78561     } catch (std::out_of_range& e) {
78562       {
78563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78564       };
78565     } catch (std::exception& e) {
78566       {
78567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78568       };
78569     } catch (...) {
78570       {
78571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78572       };
78573     }
78574   }
78575   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78576
78577   //argout typemap for const std::string&
78578
78579   return jresult;
78580 }
78581
78582
78583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78584   void * jresult ;
78585   Dali::Toolkit::TextLabel *result = 0 ;
78586
78587   {
78588     try {
78589       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78590     } catch (std::out_of_range& e) {
78591       {
78592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78593       };
78594     } catch (std::exception& e) {
78595       {
78596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78597       };
78598     } catch (...) {
78599       {
78600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78601       };
78602     }
78603   }
78604   jresult = (void *)result;
78605   return jresult;
78606 }
78607
78608
78609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78610   void * jresult ;
78611   Dali::Toolkit::TextLabel *arg1 = 0 ;
78612   Dali::Toolkit::TextLabel *result = 0 ;
78613
78614   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78615   if (!arg1) {
78616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78617     return 0;
78618   }
78619   {
78620     try {
78621       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
78622     } catch (std::out_of_range& e) {
78623       {
78624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78625       };
78626     } catch (std::exception& e) {
78627       {
78628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78629       };
78630     } catch (...) {
78631       {
78632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78633       };
78634     }
78635   }
78636   jresult = (void *)result;
78637   return jresult;
78638 }
78639
78640
78641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
78642   void * jresult ;
78643   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78644   Dali::Toolkit::TextLabel *arg2 = 0 ;
78645   Dali::Toolkit::TextLabel *result = 0 ;
78646
78647   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78648   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
78649   if (!arg2) {
78650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78651     return 0;
78652   }
78653   {
78654     try {
78655       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
78656     } catch (std::out_of_range& e) {
78657       {
78658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78659       };
78660     } catch (std::exception& e) {
78661       {
78662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78663       };
78664     } catch (...) {
78665       {
78666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78667       };
78668     }
78669   }
78670   jresult = (void *)result;
78671   return jresult;
78672 }
78673
78674
78675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
78676   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78677
78678   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78679   {
78680     try {
78681       delete arg1;
78682     } catch (std::out_of_range& e) {
78683       {
78684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78685       };
78686     } catch (std::exception& e) {
78687       {
78688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78689       };
78690     } catch (...) {
78691       {
78692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78693       };
78694     }
78695   }
78696 }
78697
78698
78699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
78700   void * jresult ;
78701   Dali::BaseHandle arg1 ;
78702   Dali::BaseHandle *argp1 ;
78703   Dali::Toolkit::TextLabel result;
78704
78705   argp1 = (Dali::BaseHandle *)jarg1;
78706   if (!argp1) {
78707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78708     return 0;
78709   }
78710   arg1 = *argp1;
78711   {
78712     try {
78713       result = Dali::Toolkit::TextLabel::DownCast(arg1);
78714     } catch (std::out_of_range& e) {
78715       {
78716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78717       };
78718     } catch (std::exception& e) {
78719       {
78720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78721       };
78722     } catch (...) {
78723       {
78724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78725       };
78726     }
78727   }
78728   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78729   return jresult;
78730 }
78731
78732
78733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
78734   void * jresult ;
78735   Dali::Toolkit::AccessibilityManager *result = 0 ;
78736
78737   {
78738     try {
78739       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
78740     } catch (std::out_of_range& e) {
78741       {
78742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78743       };
78744     } catch (std::exception& e) {
78745       {
78746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78747       };
78748     } catch (...) {
78749       {
78750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78751       };
78752     }
78753   }
78754   jresult = (void *)result;
78755   return jresult;
78756 }
78757
78758
78759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
78760   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78761
78762   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78763   {
78764     try {
78765       delete arg1;
78766     } catch (std::out_of_range& e) {
78767       {
78768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78769       };
78770     } catch (std::exception& e) {
78771       {
78772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78773       };
78774     } catch (...) {
78775       {
78776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78777       };
78778     }
78779   }
78780 }
78781
78782
78783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
78784   void * jresult ;
78785   Dali::Toolkit::AccessibilityManager result;
78786
78787   {
78788     try {
78789       result = Dali::Toolkit::AccessibilityManager::Get();
78790     } catch (std::out_of_range& e) {
78791       {
78792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78793       };
78794     } catch (std::exception& e) {
78795       {
78796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78797       };
78798     } catch (...) {
78799       {
78800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78801       };
78802     }
78803   }
78804   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
78805   return jresult;
78806 }
78807
78808
78809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
78810   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78811   Dali::Actor arg2 ;
78812   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78813   std::string *arg4 = 0 ;
78814   Dali::Actor *argp2 ;
78815
78816   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78817   argp2 = (Dali::Actor *)jarg2;
78818   if (!argp2) {
78819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78820     return ;
78821   }
78822   arg2 = *argp2;
78823   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78824   if (!jarg4) {
78825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78826     return ;
78827   }
78828   std::string arg4_str(jarg4);
78829   arg4 = &arg4_str;
78830   {
78831     try {
78832       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
78833     } catch (std::out_of_range& e) {
78834       {
78835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78836       };
78837     } catch (std::exception& e) {
78838       {
78839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78840       };
78841     } catch (...) {
78842       {
78843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78844       };
78845     }
78846   }
78847
78848   //argout typemap for const std::string&
78849
78850 }
78851
78852
78853 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
78854   char * jresult ;
78855   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78856   Dali::Actor arg2 ;
78857   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78858   Dali::Actor *argp2 ;
78859   std::string result;
78860
78861   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78862   argp2 = (Dali::Actor *)jarg2;
78863   if (!argp2) {
78864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78865     return 0;
78866   }
78867   arg2 = *argp2;
78868   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78869   {
78870     try {
78871       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
78872     } catch (std::out_of_range& e) {
78873       {
78874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78875       };
78876     } catch (std::exception& e) {
78877       {
78878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78879       };
78880     } catch (...) {
78881       {
78882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78883       };
78884     }
78885   }
78886   jresult = SWIG_csharp_string_callback((&result)->c_str());
78887   return jresult;
78888 }
78889
78890
78891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
78892   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78893   Dali::Actor arg2 ;
78894   unsigned int arg3 ;
78895   Dali::Actor *argp2 ;
78896
78897   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78898   argp2 = (Dali::Actor *)jarg2;
78899   if (!argp2) {
78900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78901     return ;
78902   }
78903   arg2 = *argp2;
78904   arg3 = (unsigned int)jarg3;
78905   {
78906     try {
78907       (arg1)->SetFocusOrder(arg2,arg3);
78908     } catch (std::out_of_range& e) {
78909       {
78910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78911       };
78912     } catch (std::exception& e) {
78913       {
78914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78915       };
78916     } catch (...) {
78917       {
78918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78919       };
78920     }
78921   }
78922 }
78923
78924
78925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
78926   unsigned int jresult ;
78927   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78928   Dali::Actor arg2 ;
78929   Dali::Actor *argp2 ;
78930   unsigned int result;
78931
78932   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78933   argp2 = (Dali::Actor *)jarg2;
78934   if (!argp2) {
78935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78936     return 0;
78937   }
78938   arg2 = *argp2;
78939   {
78940     try {
78941       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
78942     } catch (std::out_of_range& e) {
78943       {
78944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78945       };
78946     } catch (std::exception& e) {
78947       {
78948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78949       };
78950     } catch (...) {
78951       {
78952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78953       };
78954     }
78955   }
78956   jresult = result;
78957   return jresult;
78958 }
78959
78960
78961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
78962   unsigned int jresult ;
78963   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78964   unsigned int result;
78965
78966   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78967   {
78968     try {
78969       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
78970     } catch (std::out_of_range& e) {
78971       {
78972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78973       };
78974     } catch (std::exception& e) {
78975       {
78976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78977       };
78978     } catch (...) {
78979       {
78980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78981       };
78982     }
78983   }
78984   jresult = result;
78985   return jresult;
78986 }
78987
78988
78989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
78990   void * jresult ;
78991   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78992   unsigned int arg2 ;
78993   Dali::Actor result;
78994
78995   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78996   arg2 = (unsigned int)jarg2;
78997   {
78998     try {
78999       result = (arg1)->GetActorByFocusOrder(arg2);
79000     } catch (std::out_of_range& e) {
79001       {
79002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79003       };
79004     } catch (std::exception& e) {
79005       {
79006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79007       };
79008     } catch (...) {
79009       {
79010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79011       };
79012     }
79013   }
79014   jresult = new Dali::Actor((const Dali::Actor &)result);
79015   return jresult;
79016 }
79017
79018
79019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79020   unsigned int jresult ;
79021   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79022   Dali::Actor arg2 ;
79023   Dali::Actor *argp2 ;
79024   bool result;
79025
79026   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79027   argp2 = (Dali::Actor *)jarg2;
79028   if (!argp2) {
79029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79030     return 0;
79031   }
79032   arg2 = *argp2;
79033   {
79034     try {
79035       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79036     } catch (std::out_of_range& e) {
79037       {
79038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79039       };
79040     } catch (std::exception& e) {
79041       {
79042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79043       };
79044     } catch (...) {
79045       {
79046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79047       };
79048     }
79049   }
79050   jresult = result;
79051   return jresult;
79052 }
79053
79054
79055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79056   void * jresult ;
79057   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79058   Dali::Actor result;
79059
79060   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79061   {
79062     try {
79063       result = (arg1)->GetCurrentFocusActor();
79064     } catch (std::out_of_range& e) {
79065       {
79066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79067       };
79068     } catch (std::exception& e) {
79069       {
79070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79071       };
79072     } catch (...) {
79073       {
79074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79075       };
79076     }
79077   }
79078   jresult = new Dali::Actor((const Dali::Actor &)result);
79079   return jresult;
79080 }
79081
79082
79083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
79084   void * jresult ;
79085   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79086   Dali::Actor result;
79087
79088   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79089   {
79090     try {
79091       result = (arg1)->GetCurrentFocusGroup();
79092     } catch (std::out_of_range& e) {
79093       {
79094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79095       };
79096     } catch (std::exception& e) {
79097       {
79098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79099       };
79100     } catch (...) {
79101       {
79102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79103       };
79104     }
79105   }
79106   jresult = new Dali::Actor((const Dali::Actor &)result);
79107   return jresult;
79108 }
79109
79110
79111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
79112   unsigned int jresult ;
79113   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79114   unsigned int result;
79115
79116   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79117   {
79118     try {
79119       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
79120     } catch (std::out_of_range& e) {
79121       {
79122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79123       };
79124     } catch (std::exception& e) {
79125       {
79126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79127       };
79128     } catch (...) {
79129       {
79130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79131       };
79132     }
79133   }
79134   jresult = result;
79135   return jresult;
79136 }
79137
79138
79139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79140   unsigned int jresult ;
79141   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79142   bool result;
79143
79144   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79145   {
79146     try {
79147       result = (bool)(arg1)->MoveFocusForward();
79148     } catch (std::out_of_range& e) {
79149       {
79150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79151       };
79152     } catch (std::exception& e) {
79153       {
79154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79155       };
79156     } catch (...) {
79157       {
79158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79159       };
79160     }
79161   }
79162   jresult = result;
79163   return jresult;
79164 }
79165
79166
79167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79168   unsigned int jresult ;
79169   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79170   bool result;
79171
79172   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79173   {
79174     try {
79175       result = (bool)(arg1)->MoveFocusBackward();
79176     } catch (std::out_of_range& e) {
79177       {
79178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79179       };
79180     } catch (std::exception& e) {
79181       {
79182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79183       };
79184     } catch (...) {
79185       {
79186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79187       };
79188     }
79189   }
79190   jresult = result;
79191   return jresult;
79192 }
79193
79194
79195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79196   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79197
79198   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79199   {
79200     try {
79201       (arg1)->ClearFocus();
79202     } catch (std::out_of_range& e) {
79203       {
79204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79205       };
79206     } catch (std::exception& e) {
79207       {
79208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79209       };
79210     } catch (...) {
79211       {
79212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79213       };
79214     }
79215   }
79216 }
79217
79218
79219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79220   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79221
79222   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79223   {
79224     try {
79225       (arg1)->Reset();
79226     } catch (std::out_of_range& e) {
79227       {
79228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79229       };
79230     } catch (std::exception& e) {
79231       {
79232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79233       };
79234     } catch (...) {
79235       {
79236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79237       };
79238     }
79239   }
79240 }
79241
79242
79243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79244   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79245   Dali::Actor arg2 ;
79246   bool arg3 ;
79247   Dali::Actor *argp2 ;
79248
79249   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79250   argp2 = (Dali::Actor *)jarg2;
79251   if (!argp2) {
79252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79253     return ;
79254   }
79255   arg2 = *argp2;
79256   arg3 = jarg3 ? true : false;
79257   {
79258     try {
79259       (arg1)->SetFocusGroup(arg2,arg3);
79260     } catch (std::out_of_range& e) {
79261       {
79262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79263       };
79264     } catch (std::exception& e) {
79265       {
79266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79267       };
79268     } catch (...) {
79269       {
79270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79271       };
79272     }
79273   }
79274 }
79275
79276
79277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79278   unsigned int jresult ;
79279   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79280   Dali::Actor arg2 ;
79281   Dali::Actor *argp2 ;
79282   bool result;
79283
79284   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79285   argp2 = (Dali::Actor *)jarg2;
79286   if (!argp2) {
79287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79288     return 0;
79289   }
79290   arg2 = *argp2;
79291   {
79292     try {
79293       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79294     } catch (std::out_of_range& e) {
79295       {
79296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79297       };
79298     } catch (std::exception& e) {
79299       {
79300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79301       };
79302     } catch (...) {
79303       {
79304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79305       };
79306     }
79307   }
79308   jresult = result;
79309   return jresult;
79310 }
79311
79312
79313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79314   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79315   bool arg2 ;
79316
79317   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79318   arg2 = jarg2 ? true : false;
79319   {
79320     try {
79321       (arg1)->SetGroupMode(arg2);
79322     } catch (std::out_of_range& e) {
79323       {
79324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79325       };
79326     } catch (std::exception& e) {
79327       {
79328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79329       };
79330     } catch (...) {
79331       {
79332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79333       };
79334     }
79335   }
79336 }
79337
79338
79339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79340   unsigned int jresult ;
79341   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79342   bool result;
79343
79344   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79345   {
79346     try {
79347       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79348     } catch (std::out_of_range& e) {
79349       {
79350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79351       };
79352     } catch (std::exception& e) {
79353       {
79354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79355       };
79356     } catch (...) {
79357       {
79358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79359       };
79360     }
79361   }
79362   jresult = result;
79363   return jresult;
79364 }
79365
79366
79367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79368   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79369   bool arg2 ;
79370
79371   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79372   arg2 = jarg2 ? true : false;
79373   {
79374     try {
79375       (arg1)->SetWrapMode(arg2);
79376     } catch (std::out_of_range& e) {
79377       {
79378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79379       };
79380     } catch (std::exception& e) {
79381       {
79382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79383       };
79384     } catch (...) {
79385       {
79386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79387       };
79388     }
79389   }
79390 }
79391
79392
79393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
79394   unsigned int jresult ;
79395   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79396   bool result;
79397
79398   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79399   {
79400     try {
79401       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
79402     } catch (std::out_of_range& e) {
79403       {
79404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79405       };
79406     } catch (std::exception& e) {
79407       {
79408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79409       };
79410     } catch (...) {
79411       {
79412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79413       };
79414     }
79415   }
79416   jresult = result;
79417   return jresult;
79418 }
79419
79420
79421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
79422   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79423   Dali::Actor arg2 ;
79424   Dali::Actor *argp2 ;
79425
79426   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79427   argp2 = (Dali::Actor *)jarg2;
79428   if (!argp2) {
79429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79430     return ;
79431   }
79432   arg2 = *argp2;
79433   {
79434     try {
79435       (arg1)->SetFocusIndicatorActor(arg2);
79436     } catch (std::out_of_range& e) {
79437       {
79438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79439       };
79440     } catch (std::exception& e) {
79441       {
79442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79443       };
79444     } catch (...) {
79445       {
79446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79447       };
79448     }
79449   }
79450 }
79451
79452
79453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
79454   void * jresult ;
79455   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79456   Dali::Actor result;
79457
79458   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79459   {
79460     try {
79461       result = (arg1)->GetFocusIndicatorActor();
79462     } catch (std::out_of_range& e) {
79463       {
79464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79465       };
79466     } catch (std::exception& e) {
79467       {
79468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79469       };
79470     } catch (...) {
79471       {
79472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79473       };
79474     }
79475   }
79476   jresult = new Dali::Actor((const Dali::Actor &)result);
79477   return jresult;
79478 }
79479
79480
79481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
79482   void * jresult ;
79483   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79484   Dali::Actor arg2 ;
79485   Dali::Actor *argp2 ;
79486   Dali::Actor result;
79487
79488   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79489   argp2 = (Dali::Actor *)jarg2;
79490   if (!argp2) {
79491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79492     return 0;
79493   }
79494   arg2 = *argp2;
79495   {
79496     try {
79497       result = (arg1)->GetFocusGroup(arg2);
79498     } catch (std::out_of_range& e) {
79499       {
79500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79501       };
79502     } catch (std::exception& e) {
79503       {
79504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79505       };
79506     } catch (...) {
79507       {
79508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79509       };
79510     }
79511   }
79512   jresult = new Dali::Actor((const Dali::Actor &)result);
79513   return jresult;
79514 }
79515
79516
79517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
79518   void * jresult ;
79519   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79520   Dali::Vector2 result;
79521
79522   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79523   {
79524     try {
79525       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
79526     } catch (std::out_of_range& e) {
79527       {
79528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79529       };
79530     } catch (std::exception& e) {
79531       {
79532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79533       };
79534     } catch (...) {
79535       {
79536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79537       };
79538     }
79539   }
79540   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79541   return jresult;
79542 }
79543
79544
79545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
79546   void * jresult ;
79547   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79548   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
79549
79550   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79551   {
79552     try {
79553       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
79554     } catch (std::out_of_range& e) {
79555       {
79556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79557       };
79558     } catch (std::exception& e) {
79559       {
79560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79561       };
79562     } catch (...) {
79563       {
79564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79565       };
79566     }
79567   }
79568   jresult = (void *)result;
79569   return jresult;
79570 }
79571
79572
79573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
79574   void * jresult ;
79575   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79576   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
79577
79578   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79579   {
79580     try {
79581       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
79582     } catch (std::out_of_range& e) {
79583       {
79584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79585       };
79586     } catch (std::exception& e) {
79587       {
79588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79589       };
79590     } catch (...) {
79591       {
79592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79593       };
79594     }
79595   }
79596   jresult = (void *)result;
79597   return jresult;
79598 }
79599
79600
79601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
79602   void * jresult ;
79603   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79604   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
79605
79606   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79607   {
79608     try {
79609       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
79610     } catch (std::out_of_range& e) {
79611       {
79612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79613       };
79614     } catch (std::exception& e) {
79615       {
79616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79617       };
79618     } catch (...) {
79619       {
79620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79621       };
79622     }
79623   }
79624   jresult = (void *)result;
79625   return jresult;
79626 }
79627
79628
79629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
79630   void * jresult ;
79631   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79632   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79633
79634   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79635   {
79636     try {
79637       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
79638     } catch (std::out_of_range& e) {
79639       {
79640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79641       };
79642     } catch (std::exception& e) {
79643       {
79644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79645       };
79646     } catch (...) {
79647       {
79648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79649       };
79650     }
79651   }
79652   jresult = (void *)result;
79653   return jresult;
79654 }
79655
79656
79657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
79658   void * jresult ;
79659   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79660   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79661
79662   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79663   {
79664     try {
79665       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
79666     } catch (std::out_of_range& e) {
79667       {
79668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79669       };
79670     } catch (std::exception& e) {
79671       {
79672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79673       };
79674     } catch (...) {
79675       {
79676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79677       };
79678     }
79679   }
79680   jresult = (void *)result;
79681   return jresult;
79682 }
79683
79684
79685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
79686   void * jresult ;
79687   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79688   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79689
79690   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79691   {
79692     try {
79693       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
79694     } catch (std::out_of_range& e) {
79695       {
79696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79697       };
79698     } catch (std::exception& e) {
79699       {
79700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79701       };
79702     } catch (...) {
79703       {
79704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79705       };
79706     }
79707   }
79708   jresult = (void *)result;
79709   return jresult;
79710 }
79711
79712
79713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
79714   void * jresult ;
79715   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79716   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79717
79718   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79719   {
79720     try {
79721       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
79722     } catch (std::out_of_range& e) {
79723       {
79724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79725       };
79726     } catch (std::exception& e) {
79727       {
79728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79729       };
79730     } catch (...) {
79731       {
79732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79733       };
79734     }
79735   }
79736   jresult = (void *)result;
79737   return jresult;
79738 }
79739
79740
79741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
79742   void * jresult ;
79743   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79744   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79745
79746   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79747   {
79748     try {
79749       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
79750     } catch (std::out_of_range& e) {
79751       {
79752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79753       };
79754     } catch (std::exception& e) {
79755       {
79756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79757       };
79758     } catch (...) {
79759       {
79760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79761       };
79762     }
79763   }
79764   jresult = (void *)result;
79765   return jresult;
79766 }
79767
79768
79769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
79770   void * jresult ;
79771   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79772   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79773
79774   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79775   {
79776     try {
79777       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
79778     } catch (std::out_of_range& e) {
79779       {
79780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79781       };
79782     } catch (std::exception& e) {
79783       {
79784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79785       };
79786     } catch (...) {
79787       {
79788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79789       };
79790     }
79791   }
79792   jresult = (void *)result;
79793   return jresult;
79794 }
79795
79796
79797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
79798   void * jresult ;
79799   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79800   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79801
79802   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79803   {
79804     try {
79805       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
79806     } catch (std::out_of_range& e) {
79807       {
79808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79809       };
79810     } catch (std::exception& e) {
79811       {
79812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79813       };
79814     } catch (...) {
79815       {
79816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79817       };
79818     }
79819   }
79820   jresult = (void *)result;
79821   return jresult;
79822 }
79823
79824
79825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
79826   void * jresult ;
79827   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79828   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79829
79830   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79831   {
79832     try {
79833       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
79834     } catch (std::out_of_range& e) {
79835       {
79836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79837       };
79838     } catch (std::exception& e) {
79839       {
79840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79841       };
79842     } catch (...) {
79843       {
79844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79845       };
79846     }
79847   }
79848   jresult = (void *)result;
79849   return jresult;
79850 }
79851
79852
79853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
79854   void * jresult ;
79855   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79856   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79857
79858   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79859   {
79860     try {
79861       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
79862     } catch (std::out_of_range& e) {
79863       {
79864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79865       };
79866     } catch (std::exception& e) {
79867       {
79868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79869       };
79870     } catch (...) {
79871       {
79872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79873       };
79874     }
79875   }
79876   jresult = (void *)result;
79877   return jresult;
79878 }
79879
79880
79881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
79882   void * jresult ;
79883   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79884   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79885
79886   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79887   {
79888     try {
79889       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
79890     } catch (std::out_of_range& e) {
79891       {
79892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79893       };
79894     } catch (std::exception& e) {
79895       {
79896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79897       };
79898     } catch (...) {
79899       {
79900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79901       };
79902     }
79903   }
79904   jresult = (void *)result;
79905   return jresult;
79906 }
79907
79908
79909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
79910   void * jresult ;
79911   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79912   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79913
79914   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79915   {
79916     try {
79917       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
79918     } catch (std::out_of_range& e) {
79919       {
79920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79921       };
79922     } catch (std::exception& e) {
79923       {
79924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79925       };
79926     } catch (...) {
79927       {
79928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79929       };
79930     }
79931   }
79932   jresult = (void *)result;
79933   return jresult;
79934 }
79935
79936
79937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
79938   void * jresult ;
79939   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79940   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79941
79942   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79943   {
79944     try {
79945       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
79946     } catch (std::out_of_range& e) {
79947       {
79948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79949       };
79950     } catch (std::exception& e) {
79951       {
79952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79953       };
79954     } catch (...) {
79955       {
79956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79957       };
79958     }
79959   }
79960   jresult = (void *)result;
79961   return jresult;
79962 }
79963
79964
79965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
79966   void * jresult ;
79967   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79968   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79969
79970   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79971   {
79972     try {
79973       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
79974     } catch (std::out_of_range& e) {
79975       {
79976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79977       };
79978     } catch (std::exception& e) {
79979       {
79980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79981       };
79982     } catch (...) {
79983       {
79984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79985       };
79986     }
79987   }
79988   jresult = (void *)result;
79989   return jresult;
79990 }
79991
79992
79993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
79994   void * jresult ;
79995   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79996   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79997
79998   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79999   {
80000     try {
80001       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80002     } catch (std::out_of_range& e) {
80003       {
80004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80005       };
80006     } catch (std::exception& e) {
80007       {
80008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80009       };
80010     } catch (...) {
80011       {
80012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80013       };
80014     }
80015   }
80016   jresult = (void *)result;
80017   return jresult;
80018 }
80019
80020
80021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80022   void * jresult ;
80023   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80024   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80025
80026   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80027   {
80028     try {
80029       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80030     } catch (std::out_of_range& e) {
80031       {
80032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80033       };
80034     } catch (std::exception& e) {
80035       {
80036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80037       };
80038     } catch (...) {
80039       {
80040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80041       };
80042     }
80043   }
80044   jresult = (void *)result;
80045   return jresult;
80046 }
80047
80048
80049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80050   void * jresult ;
80051   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80052   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80053
80054   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80055   {
80056     try {
80057       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80058     } catch (std::out_of_range& e) {
80059       {
80060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80061       };
80062     } catch (std::exception& e) {
80063       {
80064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80065       };
80066     } catch (...) {
80067       {
80068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80069       };
80070     }
80071   }
80072   jresult = (void *)result;
80073   return jresult;
80074 }
80075
80076
80077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
80078   void * jresult ;
80079   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80080   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80081
80082   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80083   {
80084     try {
80085       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
80086     } catch (std::out_of_range& e) {
80087       {
80088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80089       };
80090     } catch (std::exception& e) {
80091       {
80092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80093       };
80094     } catch (...) {
80095       {
80096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80097       };
80098     }
80099   }
80100   jresult = (void *)result;
80101   return jresult;
80102 }
80103
80104
80105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
80106   void * jresult ;
80107   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80108   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80109
80110   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80111   {
80112     try {
80113       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
80114     } catch (std::out_of_range& e) {
80115       {
80116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80117       };
80118     } catch (std::exception& e) {
80119       {
80120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80121       };
80122     } catch (...) {
80123       {
80124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80125       };
80126     }
80127   }
80128   jresult = (void *)result;
80129   return jresult;
80130 }
80131
80132
80133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80134   void * jresult ;
80135   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80136   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80137
80138   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80139   {
80140     try {
80141       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80142     } catch (std::out_of_range& e) {
80143       {
80144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80145       };
80146     } catch (std::exception& e) {
80147       {
80148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80149       };
80150     } catch (...) {
80151       {
80152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80153       };
80154     }
80155   }
80156   jresult = (void *)result;
80157   return jresult;
80158 }
80159
80160
80161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80162   void * jresult ;
80163   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80164   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80165
80166   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80167   {
80168     try {
80169       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80170     } catch (std::out_of_range& e) {
80171       {
80172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80173       };
80174     } catch (std::exception& e) {
80175       {
80176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80177       };
80178     } catch (...) {
80179       {
80180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80181       };
80182     }
80183   }
80184   jresult = (void *)result;
80185   return jresult;
80186 }
80187
80188
80189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80190   void * jresult ;
80191   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80192   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80193
80194   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80195   {
80196     try {
80197       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80198     } catch (std::out_of_range& e) {
80199       {
80200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80201       };
80202     } catch (std::exception& e) {
80203       {
80204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80205       };
80206     } catch (...) {
80207       {
80208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80209       };
80210     }
80211   }
80212   jresult = (void *)result;
80213   return jresult;
80214 }
80215
80216
80217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80218   void * jresult ;
80219   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80220   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80221
80222   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80223   {
80224     try {
80225       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80226     } catch (std::out_of_range& e) {
80227       {
80228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80229       };
80230     } catch (std::exception& e) {
80231       {
80232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80233       };
80234     } catch (...) {
80235       {
80236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80237       };
80238     }
80239   }
80240   jresult = (void *)result;
80241   return jresult;
80242 }
80243
80244
80245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80246   void * jresult ;
80247   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80248   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80249
80250   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80251   {
80252     try {
80253       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80254     } catch (std::out_of_range& e) {
80255       {
80256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80257       };
80258     } catch (std::exception& e) {
80259       {
80260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80261       };
80262     } catch (...) {
80263       {
80264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80265       };
80266     }
80267   }
80268   jresult = (void *)result;
80269   return jresult;
80270 }
80271
80272
80273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
80274   void * jresult ;
80275   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80276   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80277
80278   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80279   {
80280     try {
80281       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
80282     } catch (std::out_of_range& e) {
80283       {
80284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80285       };
80286     } catch (std::exception& e) {
80287       {
80288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80289       };
80290     } catch (...) {
80291       {
80292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80293       };
80294     }
80295   }
80296   jresult = (void *)result;
80297   return jresult;
80298 }
80299
80300
80301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
80302   void * jresult ;
80303   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80304   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80305
80306   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80307   {
80308     try {
80309       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
80310     } catch (std::out_of_range& e) {
80311       {
80312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80313       };
80314     } catch (std::exception& e) {
80315       {
80316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80317       };
80318     } catch (...) {
80319       {
80320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80321       };
80322     }
80323   }
80324   jresult = (void *)result;
80325   return jresult;
80326 }
80327
80328
80329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
80330   void * jresult ;
80331   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80332   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80333
80334   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80335   {
80336     try {
80337       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
80338     } catch (std::out_of_range& e) {
80339       {
80340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80341       };
80342     } catch (std::exception& e) {
80343       {
80344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80345       };
80346     } catch (...) {
80347       {
80348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80349       };
80350     }
80351   }
80352   jresult = (void *)result;
80353   return jresult;
80354 }
80355
80356
80357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
80358   void * jresult ;
80359   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80360   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
80361
80362   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80363   {
80364     try {
80365       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
80366     } catch (std::out_of_range& e) {
80367       {
80368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80369       };
80370     } catch (std::exception& e) {
80371       {
80372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80373       };
80374     } catch (...) {
80375       {
80376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80377       };
80378     }
80379   }
80380   jresult = (void *)result;
80381   return jresult;
80382 }
80383
80384
80385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
80386   void * jresult ;
80387   Dali::Toolkit::StyleManager *result = 0 ;
80388
80389   {
80390     try {
80391       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
80392     } catch (std::out_of_range& e) {
80393       {
80394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80395       };
80396     } catch (std::exception& e) {
80397       {
80398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80399       };
80400     } catch (...) {
80401       {
80402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80403       };
80404     }
80405   }
80406   jresult = (void *)result;
80407   return jresult;
80408 }
80409
80410
80411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
80412   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80413
80414   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80415   {
80416     try {
80417       delete arg1;
80418     } catch (std::out_of_range& e) {
80419       {
80420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80421       };
80422     } catch (std::exception& e) {
80423       {
80424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80425       };
80426     } catch (...) {
80427       {
80428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80429       };
80430     }
80431   }
80432 }
80433
80434
80435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
80436   void * jresult ;
80437   Dali::Toolkit::StyleManager result;
80438
80439   {
80440     try {
80441       result = Dali::Toolkit::StyleManager::Get();
80442     } catch (std::out_of_range& e) {
80443       {
80444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80445       };
80446     } catch (std::exception& e) {
80447       {
80448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80449       };
80450     } catch (...) {
80451       {
80452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80453       };
80454     }
80455   }
80456   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
80457   return jresult;
80458 }
80459
80460
80461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
80462   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80463   std::string *arg2 = 0 ;
80464
80465   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80466   if (!jarg2) {
80467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80468     return ;
80469   }
80470   std::string arg2_str(jarg2);
80471   arg2 = &arg2_str;
80472   {
80473     try {
80474       (arg1)->ApplyTheme((std::string const &)*arg2);
80475     } catch (std::out_of_range& e) {
80476       {
80477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80478       };
80479     } catch (std::exception& e) {
80480       {
80481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80482       };
80483     } catch (...) {
80484       {
80485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80486       };
80487     }
80488   }
80489
80490   //argout typemap for const std::string&
80491
80492 }
80493
80494
80495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
80496   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80497
80498   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80499   {
80500     try {
80501       (arg1)->ApplyDefaultTheme();
80502     } catch (std::out_of_range& e) {
80503       {
80504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80505       };
80506     } catch (std::exception& e) {
80507       {
80508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80509       };
80510     } catch (...) {
80511       {
80512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80513       };
80514     }
80515   }
80516 }
80517
80518
80519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80520   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80521   std::string *arg2 = 0 ;
80522   Dali::Property::Value *arg3 = 0 ;
80523
80524   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80525   if (!jarg2) {
80526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80527     return ;
80528   }
80529   std::string arg2_str(jarg2);
80530   arg2 = &arg2_str;
80531   arg3 = (Dali::Property::Value *)jarg3;
80532   if (!arg3) {
80533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
80534     return ;
80535   }
80536   {
80537     try {
80538       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
80539     } catch (std::out_of_range& e) {
80540       {
80541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80542       };
80543     } catch (std::exception& e) {
80544       {
80545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80546       };
80547     } catch (...) {
80548       {
80549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80550       };
80551     }
80552   }
80553
80554   //argout typemap for const std::string&
80555
80556 }
80557
80558
80559 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80560   unsigned int jresult ;
80561   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80562   std::string *arg2 = 0 ;
80563   Dali::Property::Value *arg3 = 0 ;
80564   bool result;
80565
80566   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80567   if (!jarg2) {
80568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80569     return 0;
80570   }
80571   std::string arg2_str(jarg2);
80572   arg2 = &arg2_str;
80573   arg3 = (Dali::Property::Value *)jarg3;
80574   if (!arg3) {
80575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
80576     return 0;
80577   }
80578   {
80579     try {
80580       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
80581     } catch (std::out_of_range& e) {
80582       {
80583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80584       };
80585     } catch (std::exception& e) {
80586       {
80587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80588       };
80589     } catch (...) {
80590       {
80591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80592       };
80593     }
80594   }
80595   jresult = result;
80596
80597   //argout typemap for const std::string&
80598
80599   return jresult;
80600 }
80601
80602
80603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
80604   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80605   Dali::Toolkit::Control arg2 ;
80606   std::string *arg3 = 0 ;
80607   std::string *arg4 = 0 ;
80608   Dali::Toolkit::Control *argp2 ;
80609
80610   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80611   argp2 = (Dali::Toolkit::Control *)jarg2;
80612   if (!argp2) {
80613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
80614     return ;
80615   }
80616   arg2 = *argp2;
80617   if (!jarg3) {
80618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80619     return ;
80620   }
80621   std::string arg3_str(jarg3);
80622   arg3 = &arg3_str;
80623   if (!jarg4) {
80624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80625     return ;
80626   }
80627   std::string arg4_str(jarg4);
80628   arg4 = &arg4_str;
80629   {
80630     try {
80631       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
80632     } catch (std::out_of_range& e) {
80633       {
80634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80635       };
80636     } catch (std::exception& e) {
80637       {
80638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80639       };
80640     } catch (...) {
80641       {
80642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80643       };
80644     }
80645   }
80646
80647   //argout typemap for const std::string&
80648
80649
80650   //argout typemap for const std::string&
80651
80652 }
80653
80654
80655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
80656   void * jresult ;
80657   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80658   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
80659
80660   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80661   {
80662     try {
80663       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
80664     } catch (std::out_of_range& e) {
80665       {
80666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80667       };
80668     } catch (std::exception& e) {
80669       {
80670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80671       };
80672     } catch (...) {
80673       {
80674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80675       };
80676     }
80677   }
80678   jresult = (void *)result;
80679   return jresult;
80680 }
80681
80682
80683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
80684   int jresult ;
80685   int result;
80686
80687   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
80688   jresult = (int)result;
80689   return jresult;
80690 }
80691
80692
80693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
80694   int jresult ;
80695   int result;
80696
80697   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
80698   jresult = (int)result;
80699   return jresult;
80700 }
80701
80702
80703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
80704   int jresult ;
80705   int result;
80706
80707   result = (int)Dali::Toolkit::Slider::Property::VALUE;
80708   jresult = (int)result;
80709   return jresult;
80710 }
80711
80712
80713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
80714   int jresult ;
80715   int result;
80716
80717   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
80718   jresult = (int)result;
80719   return jresult;
80720 }
80721
80722
80723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
80724   int jresult ;
80725   int result;
80726
80727   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
80728   jresult = (int)result;
80729   return jresult;
80730 }
80731
80732
80733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
80734   int jresult ;
80735   int result;
80736
80737   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
80738   jresult = (int)result;
80739   return jresult;
80740 }
80741
80742
80743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
80744   int jresult ;
80745   int result;
80746
80747   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
80748   jresult = (int)result;
80749   return jresult;
80750 }
80751
80752
80753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
80754   int jresult ;
80755   int result;
80756
80757   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
80758   jresult = (int)result;
80759   return jresult;
80760 }
80761
80762
80763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
80764   int jresult ;
80765   int result;
80766
80767   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
80768   jresult = (int)result;
80769   return jresult;
80770 }
80771
80772
80773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
80774   int jresult ;
80775   int result;
80776
80777   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
80778   jresult = (int)result;
80779   return jresult;
80780 }
80781
80782
80783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
80784   int jresult ;
80785   int result;
80786
80787   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
80788   jresult = (int)result;
80789   return jresult;
80790 }
80791
80792
80793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
80794   int jresult ;
80795   int result;
80796
80797   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
80798   jresult = (int)result;
80799   return jresult;
80800 }
80801
80802
80803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
80804   int jresult ;
80805   int result;
80806
80807   result = (int)Dali::Toolkit::Slider::Property::MARKS;
80808   jresult = (int)result;
80809   return jresult;
80810 }
80811
80812
80813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
80814   int jresult ;
80815   int result;
80816
80817   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
80818   jresult = (int)result;
80819   return jresult;
80820 }
80821
80822
80823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
80824   int jresult ;
80825   int result;
80826
80827   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
80828   jresult = (int)result;
80829   return jresult;
80830 }
80831
80832
80833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
80834   void * jresult ;
80835   Dali::Toolkit::Slider::Property *result = 0 ;
80836
80837   {
80838     try {
80839       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
80840     } catch (std::out_of_range& e) {
80841       {
80842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80843       };
80844     } catch (std::exception& e) {
80845       {
80846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80847       };
80848     } catch (...) {
80849       {
80850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80851       };
80852     }
80853   }
80854   jresult = (void *)result;
80855   return jresult;
80856 }
80857
80858
80859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
80860   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
80861
80862   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
80863   {
80864     try {
80865       delete arg1;
80866     } catch (std::out_of_range& e) {
80867       {
80868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80869       };
80870     } catch (std::exception& e) {
80871       {
80872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80873       };
80874     } catch (...) {
80875       {
80876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80877       };
80878     }
80879   }
80880 }
80881
80882
80883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
80884   void * jresult ;
80885   Dali::Toolkit::Slider result;
80886
80887   {
80888     try {
80889       result = Dali::Toolkit::Slider::New();
80890     } catch (std::out_of_range& e) {
80891       {
80892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80893       };
80894     } catch (std::exception& e) {
80895       {
80896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80897       };
80898     } catch (...) {
80899       {
80900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80901       };
80902     }
80903   }
80904   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
80905   return jresult;
80906 }
80907
80908
80909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
80910   void * jresult ;
80911   Dali::Toolkit::Slider *result = 0 ;
80912
80913   {
80914     try {
80915       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
80916     } catch (std::out_of_range& e) {
80917       {
80918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80919       };
80920     } catch (std::exception& e) {
80921       {
80922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80923       };
80924     } catch (...) {
80925       {
80926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80927       };
80928     }
80929   }
80930   jresult = (void *)result;
80931   return jresult;
80932 }
80933
80934
80935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
80936   void * jresult ;
80937   Dali::Toolkit::Slider *arg1 = 0 ;
80938   Dali::Toolkit::Slider *result = 0 ;
80939
80940   arg1 = (Dali::Toolkit::Slider *)jarg1;
80941   if (!arg1) {
80942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
80943     return 0;
80944   }
80945   {
80946     try {
80947       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
80948     } catch (std::out_of_range& e) {
80949       {
80950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80951       };
80952     } catch (std::exception& e) {
80953       {
80954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80955       };
80956     } catch (...) {
80957       {
80958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80959       };
80960     }
80961   }
80962   jresult = (void *)result;
80963   return jresult;
80964 }
80965
80966
80967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
80968   void * jresult ;
80969   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80970   Dali::Toolkit::Slider *arg2 = 0 ;
80971   Dali::Toolkit::Slider *result = 0 ;
80972
80973   arg1 = (Dali::Toolkit::Slider *)jarg1;
80974   arg2 = (Dali::Toolkit::Slider *)jarg2;
80975   if (!arg2) {
80976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
80977     return 0;
80978   }
80979   {
80980     try {
80981       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
80982     } catch (std::out_of_range& e) {
80983       {
80984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80985       };
80986     } catch (std::exception& e) {
80987       {
80988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80989       };
80990     } catch (...) {
80991       {
80992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80993       };
80994     }
80995   }
80996   jresult = (void *)result;
80997   return jresult;
80998 }
80999
81000
81001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
81002   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81003
81004   arg1 = (Dali::Toolkit::Slider *)jarg1;
81005   {
81006     try {
81007       delete arg1;
81008     } catch (std::out_of_range& e) {
81009       {
81010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81011       };
81012     } catch (std::exception& e) {
81013       {
81014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81015       };
81016     } catch (...) {
81017       {
81018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81019       };
81020     }
81021   }
81022 }
81023
81024
81025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
81026   void * jresult ;
81027   Dali::BaseHandle arg1 ;
81028   Dali::BaseHandle *argp1 ;
81029   Dali::Toolkit::Slider result;
81030
81031   argp1 = (Dali::BaseHandle *)jarg1;
81032   if (!argp1) {
81033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81034     return 0;
81035   }
81036   arg1 = *argp1;
81037   {
81038     try {
81039       result = Dali::Toolkit::Slider::DownCast(arg1);
81040     } catch (std::out_of_range& e) {
81041       {
81042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81043       };
81044     } catch (std::exception& e) {
81045       {
81046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81047       };
81048     } catch (...) {
81049       {
81050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81051       };
81052     }
81053   }
81054   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81055   return jresult;
81056 }
81057
81058
81059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
81060   void * jresult ;
81061   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81062   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81063
81064   arg1 = (Dali::Toolkit::Slider *)jarg1;
81065   {
81066     try {
81067       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
81068     } catch (std::out_of_range& e) {
81069       {
81070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81071       };
81072     } catch (std::exception& e) {
81073       {
81074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81075       };
81076     } catch (...) {
81077       {
81078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81079       };
81080     }
81081   }
81082   jresult = (void *)result;
81083   return jresult;
81084 }
81085
81086
81087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
81088   void * jresult ;
81089   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81090   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81091
81092   arg1 = (Dali::Toolkit::Slider *)jarg1;
81093   {
81094     try {
81095       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
81096     } catch (std::out_of_range& e) {
81097       {
81098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81099       };
81100     } catch (std::exception& e) {
81101       {
81102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81103       };
81104     } catch (...) {
81105       {
81106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81107       };
81108     }
81109   }
81110   jresult = (void *)result;
81111   return jresult;
81112 }
81113
81114
81115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
81116   void * jresult ;
81117   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81118   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
81119
81120   arg1 = (Dali::Toolkit::Slider *)jarg1;
81121   {
81122     try {
81123       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
81124     } catch (std::out_of_range& e) {
81125       {
81126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81127       };
81128     } catch (std::exception& e) {
81129       {
81130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81131       };
81132     } catch (...) {
81133       {
81134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81135       };
81136     }
81137   }
81138   jresult = (void *)result;
81139   return jresult;
81140 }
81141
81142
81143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
81144   int jresult ;
81145   int result;
81146
81147   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
81148   jresult = (int)result;
81149   return jresult;
81150 }
81151
81152
81153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
81154   int jresult ;
81155   int result;
81156
81157   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
81158   jresult = (int)result;
81159   return jresult;
81160 }
81161
81162
81163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
81164   int jresult ;
81165   int result;
81166
81167   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
81168   jresult = (int)result;
81169   return jresult;
81170 }
81171
81172
81173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
81174   int jresult ;
81175   int result;
81176
81177   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
81178   jresult = (int)result;
81179   return jresult;
81180 }
81181
81182
81183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
81184   void * jresult ;
81185   Dali::Toolkit::VideoView::Property *result = 0 ;
81186
81187   {
81188     try {
81189       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
81190     } catch (std::out_of_range& e) {
81191       {
81192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81193       };
81194     } catch (std::exception& e) {
81195       {
81196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81197       };
81198     } catch (...) {
81199       {
81200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81201       };
81202     }
81203   }
81204   jresult = (void *)result;
81205   return jresult;
81206 }
81207
81208
81209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
81210   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
81211
81212   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
81213   {
81214     try {
81215       delete arg1;
81216     } catch (std::out_of_range& e) {
81217       {
81218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81219       };
81220     } catch (std::exception& e) {
81221       {
81222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81223       };
81224     } catch (...) {
81225       {
81226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81227       };
81228     }
81229   }
81230 }
81231
81232
81233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
81234   void * jresult ;
81235   Dali::Toolkit::VideoView result;
81236
81237   {
81238     try {
81239       result = Dali::Toolkit::VideoView::New();
81240     } catch (std::out_of_range& e) {
81241       {
81242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81243       };
81244     } catch (std::exception& e) {
81245       {
81246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81247       };
81248     } catch (...) {
81249       {
81250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81251       };
81252     }
81253   }
81254   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81255   return jresult;
81256 }
81257
81258
81259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
81260   void * jresult ;
81261   std::string *arg1 = 0 ;
81262   Dali::Toolkit::VideoView result;
81263
81264   if (!jarg1) {
81265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81266     return 0;
81267   }
81268   std::string arg1_str(jarg1);
81269   arg1 = &arg1_str;
81270   {
81271     try {
81272       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
81273     } catch (std::out_of_range& e) {
81274       {
81275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81276       };
81277     } catch (std::exception& e) {
81278       {
81279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81280       };
81281     } catch (...) {
81282       {
81283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81284       };
81285     }
81286   }
81287   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81288
81289   //argout typemap for const std::string&
81290
81291   return jresult;
81292 }
81293
81294
81295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
81296   void * jresult ;
81297   Dali::Toolkit::VideoView *result = 0 ;
81298
81299   {
81300     try {
81301       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
81302     } catch (std::out_of_range& e) {
81303       {
81304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81305       };
81306     } catch (std::exception& e) {
81307       {
81308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81309       };
81310     } catch (...) {
81311       {
81312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81313       };
81314     }
81315   }
81316   jresult = (void *)result;
81317   return jresult;
81318 }
81319
81320
81321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
81322   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81323
81324   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81325   {
81326     try {
81327       delete arg1;
81328     } catch (std::out_of_range& e) {
81329       {
81330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81331       };
81332     } catch (std::exception& e) {
81333       {
81334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81335       };
81336     } catch (...) {
81337       {
81338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81339       };
81340     }
81341   }
81342 }
81343
81344
81345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
81346   void * jresult ;
81347   Dali::Toolkit::VideoView *arg1 = 0 ;
81348   Dali::Toolkit::VideoView *result = 0 ;
81349
81350   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81351   if (!arg1) {
81352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81353     return 0;
81354   }
81355   {
81356     try {
81357       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
81358     } catch (std::out_of_range& e) {
81359       {
81360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81361       };
81362     } catch (std::exception& e) {
81363       {
81364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81365       };
81366     } catch (...) {
81367       {
81368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81369       };
81370     }
81371   }
81372   jresult = (void *)result;
81373   return jresult;
81374 }
81375
81376
81377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
81378   void * jresult ;
81379   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81380   Dali::Toolkit::VideoView *arg2 = 0 ;
81381   Dali::Toolkit::VideoView *result = 0 ;
81382
81383   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81384   arg2 = (Dali::Toolkit::VideoView *)jarg2;
81385   if (!arg2) {
81386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81387     return 0;
81388   }
81389   {
81390     try {
81391       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
81392     } catch (std::out_of_range& e) {
81393       {
81394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81395       };
81396     } catch (std::exception& e) {
81397       {
81398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81399       };
81400     } catch (...) {
81401       {
81402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81403       };
81404     }
81405   }
81406   jresult = (void *)result;
81407   return jresult;
81408 }
81409
81410
81411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
81412   void * jresult ;
81413   Dali::BaseHandle arg1 ;
81414   Dali::BaseHandle *argp1 ;
81415   Dali::Toolkit::VideoView result;
81416
81417   argp1 = (Dali::BaseHandle *)jarg1;
81418   if (!argp1) {
81419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81420     return 0;
81421   }
81422   arg1 = *argp1;
81423   {
81424     try {
81425       result = Dali::Toolkit::VideoView::DownCast(arg1);
81426     } catch (std::out_of_range& e) {
81427       {
81428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81429       };
81430     } catch (std::exception& e) {
81431       {
81432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81433       };
81434     } catch (...) {
81435       {
81436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81437       };
81438     }
81439   }
81440   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81441   return jresult;
81442 }
81443
81444
81445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
81446   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81447
81448   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81449   {
81450     try {
81451       (arg1)->Play();
81452     } catch (std::out_of_range& e) {
81453       {
81454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81455       };
81456     } catch (std::exception& e) {
81457       {
81458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81459       };
81460     } catch (...) {
81461       {
81462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81463       };
81464     }
81465   }
81466 }
81467
81468
81469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
81470   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81471
81472   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81473   {
81474     try {
81475       (arg1)->Pause();
81476     } catch (std::out_of_range& e) {
81477       {
81478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81479       };
81480     } catch (std::exception& e) {
81481       {
81482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81483       };
81484     } catch (...) {
81485       {
81486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81487       };
81488     }
81489   }
81490 }
81491
81492
81493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
81494   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81495
81496   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81497   {
81498     try {
81499       (arg1)->Stop();
81500     } catch (std::out_of_range& e) {
81501       {
81502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81503       };
81504     } catch (std::exception& e) {
81505       {
81506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81507       };
81508     } catch (...) {
81509       {
81510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81511       };
81512     }
81513   }
81514 }
81515
81516
81517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
81518   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81519   int arg2 ;
81520
81521   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81522   arg2 = (int)jarg2;
81523   {
81524     try {
81525       (arg1)->Forward(arg2);
81526     } catch (std::out_of_range& e) {
81527       {
81528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81529       };
81530     } catch (std::exception& e) {
81531       {
81532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81533       };
81534     } catch (...) {
81535       {
81536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81537       };
81538     }
81539   }
81540 }
81541
81542
81543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
81544   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81545   int arg2 ;
81546
81547   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81548   arg2 = (int)jarg2;
81549   {
81550     try {
81551       (arg1)->Backward(arg2);
81552     } catch (std::out_of_range& e) {
81553       {
81554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81555       };
81556     } catch (std::exception& e) {
81557       {
81558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81559       };
81560     } catch (...) {
81561       {
81562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81563       };
81564     }
81565   }
81566 }
81567
81568
81569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
81570   void * jresult ;
81571   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81572   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
81573
81574   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81575   {
81576     try {
81577       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
81578     } catch (std::out_of_range& e) {
81579       {
81580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81581       };
81582     } catch (std::exception& e) {
81583       {
81584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81585       };
81586     } catch (...) {
81587       {
81588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81589       };
81590     }
81591   }
81592   jresult = (void *)result;
81593   return jresult;
81594 }
81595
81596
81597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
81598   int jresult ;
81599   int result;
81600
81601   result = (int)Dali::Toolkit::Popup::Property::TITLE;
81602   jresult = (int)result;
81603   return jresult;
81604 }
81605
81606
81607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
81608   int jresult ;
81609   int result;
81610
81611   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
81612   jresult = (int)result;
81613   return jresult;
81614 }
81615
81616
81617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
81618   int jresult ;
81619   int result;
81620
81621   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
81622   jresult = (int)result;
81623   return jresult;
81624 }
81625
81626
81627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
81628   int jresult ;
81629   int result;
81630
81631   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
81632   jresult = (int)result;
81633   return jresult;
81634 }
81635
81636
81637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
81638   int jresult ;
81639   int result;
81640
81641   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
81642   jresult = (int)result;
81643   return jresult;
81644 }
81645
81646
81647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
81648   int jresult ;
81649   int result;
81650
81651   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
81652   jresult = (int)result;
81653   return jresult;
81654 }
81655
81656
81657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
81658   int jresult ;
81659   int result;
81660
81661   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
81662   jresult = (int)result;
81663   return jresult;
81664 }
81665
81666
81667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
81668   int jresult ;
81669   int result;
81670
81671   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
81672   jresult = (int)result;
81673   return jresult;
81674 }
81675
81676
81677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
81678   int jresult ;
81679   int result;
81680
81681   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
81682   jresult = (int)result;
81683   return jresult;
81684 }
81685
81686
81687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
81688   int jresult ;
81689   int result;
81690
81691   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
81692   jresult = (int)result;
81693   return jresult;
81694 }
81695
81696
81697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
81698   int jresult ;
81699   int result;
81700
81701   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
81702   jresult = (int)result;
81703   return jresult;
81704 }
81705
81706
81707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
81708   int jresult ;
81709   int result;
81710
81711   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
81712   jresult = (int)result;
81713   return jresult;
81714 }
81715
81716
81717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
81718   int jresult ;
81719   int result;
81720
81721   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
81722   jresult = (int)result;
81723   return jresult;
81724 }
81725
81726
81727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
81728   int jresult ;
81729   int result;
81730
81731   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
81732   jresult = (int)result;
81733   return jresult;
81734 }
81735
81736
81737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
81738   int jresult ;
81739   int result;
81740
81741   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
81742   jresult = (int)result;
81743   return jresult;
81744 }
81745
81746
81747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
81748   int jresult ;
81749   int result;
81750
81751   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
81752   jresult = (int)result;
81753   return jresult;
81754 }
81755
81756
81757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
81758   int jresult ;
81759   int result;
81760
81761   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
81762   jresult = (int)result;
81763   return jresult;
81764 }
81765
81766
81767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
81768   int jresult ;
81769   int result;
81770
81771   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
81772   jresult = (int)result;
81773   return jresult;
81774 }
81775
81776
81777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
81778   int jresult ;
81779   int result;
81780
81781   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
81782   jresult = (int)result;
81783   return jresult;
81784 }
81785
81786
81787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
81788   int jresult ;
81789   int result;
81790
81791   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
81792   jresult = (int)result;
81793   return jresult;
81794 }
81795
81796
81797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
81798   int jresult ;
81799   int result;
81800
81801   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
81802   jresult = (int)result;
81803   return jresult;
81804 }
81805
81806
81807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
81808   void * jresult ;
81809   Dali::Toolkit::Popup::Property *result = 0 ;
81810
81811   {
81812     try {
81813       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
81814     } catch (std::out_of_range& e) {
81815       {
81816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81817       };
81818     } catch (std::exception& e) {
81819       {
81820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81821       };
81822     } catch (...) {
81823       {
81824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81825       };
81826     }
81827   }
81828   jresult = (void *)result;
81829   return jresult;
81830 }
81831
81832
81833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
81834   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
81835
81836   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
81837   {
81838     try {
81839       delete arg1;
81840     } catch (std::out_of_range& e) {
81841       {
81842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81843       };
81844     } catch (std::exception& e) {
81845       {
81846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81847       };
81848     } catch (...) {
81849       {
81850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81851       };
81852     }
81853   }
81854 }
81855
81856
81857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
81858   void * jresult ;
81859   Dali::Toolkit::Popup *result = 0 ;
81860
81861   {
81862     try {
81863       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
81864     } catch (std::out_of_range& e) {
81865       {
81866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81867       };
81868     } catch (std::exception& e) {
81869       {
81870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81871       };
81872     } catch (...) {
81873       {
81874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81875       };
81876     }
81877   }
81878   jresult = (void *)result;
81879   return jresult;
81880 }
81881
81882
81883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
81884   void * jresult ;
81885   Dali::Toolkit::Popup result;
81886
81887   {
81888     try {
81889       result = Dali::Toolkit::Popup::New();
81890     } catch (std::out_of_range& e) {
81891       {
81892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81893       };
81894     } catch (std::exception& e) {
81895       {
81896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81897       };
81898     } catch (...) {
81899       {
81900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81901       };
81902     }
81903   }
81904   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
81905   return jresult;
81906 }
81907
81908
81909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
81910   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81911
81912   arg1 = (Dali::Toolkit::Popup *)jarg1;
81913   {
81914     try {
81915       delete arg1;
81916     } catch (std::out_of_range& e) {
81917       {
81918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81919       };
81920     } catch (std::exception& e) {
81921       {
81922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81923       };
81924     } catch (...) {
81925       {
81926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81927       };
81928     }
81929   }
81930 }
81931
81932
81933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
81934   void * jresult ;
81935   Dali::Toolkit::Popup *arg1 = 0 ;
81936   Dali::Toolkit::Popup *result = 0 ;
81937
81938   arg1 = (Dali::Toolkit::Popup *)jarg1;
81939   if (!arg1) {
81940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
81941     return 0;
81942   }
81943   {
81944     try {
81945       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
81946     } catch (std::out_of_range& e) {
81947       {
81948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81949       };
81950     } catch (std::exception& e) {
81951       {
81952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81953       };
81954     } catch (...) {
81955       {
81956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81957       };
81958     }
81959   }
81960   jresult = (void *)result;
81961   return jresult;
81962 }
81963
81964
81965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
81966   void * jresult ;
81967   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81968   Dali::Toolkit::Popup *arg2 = 0 ;
81969   Dali::Toolkit::Popup *result = 0 ;
81970
81971   arg1 = (Dali::Toolkit::Popup *)jarg1;
81972   arg2 = (Dali::Toolkit::Popup *)jarg2;
81973   if (!arg2) {
81974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
81975     return 0;
81976   }
81977   {
81978     try {
81979       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
81980     } catch (std::out_of_range& e) {
81981       {
81982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81983       };
81984     } catch (std::exception& e) {
81985       {
81986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81987       };
81988     } catch (...) {
81989       {
81990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81991       };
81992     }
81993   }
81994   jresult = (void *)result;
81995   return jresult;
81996 }
81997
81998
81999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
82000   void * jresult ;
82001   Dali::BaseHandle arg1 ;
82002   Dali::BaseHandle *argp1 ;
82003   Dali::Toolkit::Popup result;
82004
82005   argp1 = (Dali::BaseHandle *)jarg1;
82006   if (!argp1) {
82007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82008     return 0;
82009   }
82010   arg1 = *argp1;
82011   {
82012     try {
82013       result = Dali::Toolkit::Popup::DownCast(arg1);
82014     } catch (std::out_of_range& e) {
82015       {
82016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82017       };
82018     } catch (std::exception& e) {
82019       {
82020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82021       };
82022     } catch (...) {
82023       {
82024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82025       };
82026     }
82027   }
82028   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82029   return jresult;
82030 }
82031
82032
82033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
82034   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82035   Dali::Actor arg2 ;
82036   Dali::Actor *argp2 ;
82037
82038   arg1 = (Dali::Toolkit::Popup *)jarg1;
82039   argp2 = (Dali::Actor *)jarg2;
82040   if (!argp2) {
82041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82042     return ;
82043   }
82044   arg2 = *argp2;
82045   {
82046     try {
82047       (arg1)->SetTitle(arg2);
82048     } catch (std::out_of_range& e) {
82049       {
82050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82051       };
82052     } catch (std::exception& e) {
82053       {
82054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82055       };
82056     } catch (...) {
82057       {
82058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82059       };
82060     }
82061   }
82062 }
82063
82064
82065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
82066   void * jresult ;
82067   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82068   Dali::Actor result;
82069
82070   arg1 = (Dali::Toolkit::Popup *)jarg1;
82071   {
82072     try {
82073       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
82074     } catch (std::out_of_range& e) {
82075       {
82076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82077       };
82078     } catch (std::exception& e) {
82079       {
82080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82081       };
82082     } catch (...) {
82083       {
82084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82085       };
82086     }
82087   }
82088   jresult = new Dali::Actor((const Dali::Actor &)result);
82089   return jresult;
82090 }
82091
82092
82093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
82094   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82095   Dali::Actor arg2 ;
82096   Dali::Actor *argp2 ;
82097
82098   arg1 = (Dali::Toolkit::Popup *)jarg1;
82099   argp2 = (Dali::Actor *)jarg2;
82100   if (!argp2) {
82101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82102     return ;
82103   }
82104   arg2 = *argp2;
82105   {
82106     try {
82107       (arg1)->SetContent(arg2);
82108     } catch (std::out_of_range& e) {
82109       {
82110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82111       };
82112     } catch (std::exception& e) {
82113       {
82114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82115       };
82116     } catch (...) {
82117       {
82118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82119       };
82120     }
82121   }
82122 }
82123
82124
82125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
82126   void * jresult ;
82127   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82128   Dali::Actor result;
82129
82130   arg1 = (Dali::Toolkit::Popup *)jarg1;
82131   {
82132     try {
82133       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
82134     } catch (std::out_of_range& e) {
82135       {
82136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82137       };
82138     } catch (std::exception& e) {
82139       {
82140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82141       };
82142     } catch (...) {
82143       {
82144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82145       };
82146     }
82147   }
82148   jresult = new Dali::Actor((const Dali::Actor &)result);
82149   return jresult;
82150 }
82151
82152
82153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
82154   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82155   Dali::Actor arg2 ;
82156   Dali::Actor *argp2 ;
82157
82158   arg1 = (Dali::Toolkit::Popup *)jarg1;
82159   argp2 = (Dali::Actor *)jarg2;
82160   if (!argp2) {
82161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82162     return ;
82163   }
82164   arg2 = *argp2;
82165   {
82166     try {
82167       (arg1)->SetFooter(arg2);
82168     } catch (std::out_of_range& e) {
82169       {
82170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82171       };
82172     } catch (std::exception& e) {
82173       {
82174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82175       };
82176     } catch (...) {
82177       {
82178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82179       };
82180     }
82181   }
82182 }
82183
82184
82185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
82186   void * jresult ;
82187   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82188   Dali::Actor result;
82189
82190   arg1 = (Dali::Toolkit::Popup *)jarg1;
82191   {
82192     try {
82193       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
82194     } catch (std::out_of_range& e) {
82195       {
82196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82197       };
82198     } catch (std::exception& e) {
82199       {
82200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82201       };
82202     } catch (...) {
82203       {
82204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82205       };
82206     }
82207   }
82208   jresult = new Dali::Actor((const Dali::Actor &)result);
82209   return jresult;
82210 }
82211
82212
82213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
82214   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82215   Dali::Toolkit::Popup::DisplayState arg2 ;
82216
82217   arg1 = (Dali::Toolkit::Popup *)jarg1;
82218   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
82219   {
82220     try {
82221       (arg1)->SetDisplayState(arg2);
82222     } catch (std::out_of_range& e) {
82223       {
82224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82225       };
82226     } catch (std::exception& e) {
82227       {
82228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82229       };
82230     } catch (...) {
82231       {
82232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82233       };
82234     }
82235   }
82236 }
82237
82238
82239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
82240   int jresult ;
82241   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82242   Dali::Toolkit::Popup::DisplayState result;
82243
82244   arg1 = (Dali::Toolkit::Popup *)jarg1;
82245   {
82246     try {
82247       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
82248     } catch (std::out_of_range& e) {
82249       {
82250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82251       };
82252     } catch (std::exception& e) {
82253       {
82254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82255       };
82256     } catch (...) {
82257       {
82258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82259       };
82260     }
82261   }
82262   jresult = (int)result;
82263   return jresult;
82264 }
82265
82266
82267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
82268   void * jresult ;
82269   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82270   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
82271
82272   arg1 = (Dali::Toolkit::Popup *)jarg1;
82273   {
82274     try {
82275       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
82276     } catch (std::out_of_range& e) {
82277       {
82278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82279       };
82280     } catch (std::exception& e) {
82281       {
82282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82283       };
82284     } catch (...) {
82285       {
82286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82287       };
82288     }
82289   }
82290   jresult = (void *)result;
82291   return jresult;
82292 }
82293
82294
82295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
82296   void * jresult ;
82297   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82298   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82299
82300   arg1 = (Dali::Toolkit::Popup *)jarg1;
82301   {
82302     try {
82303       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
82304     } catch (std::out_of_range& e) {
82305       {
82306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82307       };
82308     } catch (std::exception& e) {
82309       {
82310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82311       };
82312     } catch (...) {
82313       {
82314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82315       };
82316     }
82317   }
82318   jresult = (void *)result;
82319   return jresult;
82320 }
82321
82322
82323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
82324   void * jresult ;
82325   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82326   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82327
82328   arg1 = (Dali::Toolkit::Popup *)jarg1;
82329   {
82330     try {
82331       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
82332     } catch (std::out_of_range& e) {
82333       {
82334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82335       };
82336     } catch (std::exception& e) {
82337       {
82338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82339       };
82340     } catch (...) {
82341       {
82342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82343       };
82344     }
82345   }
82346   jresult = (void *)result;
82347   return jresult;
82348 }
82349
82350
82351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
82352   void * jresult ;
82353   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82354   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82355
82356   arg1 = (Dali::Toolkit::Popup *)jarg1;
82357   {
82358     try {
82359       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
82360     } catch (std::out_of_range& e) {
82361       {
82362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82363       };
82364     } catch (std::exception& e) {
82365       {
82366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82367       };
82368     } catch (...) {
82369       {
82370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82371       };
82372     }
82373   }
82374   jresult = (void *)result;
82375   return jresult;
82376 }
82377
82378
82379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
82380   void * jresult ;
82381   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82382   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82383
82384   arg1 = (Dali::Toolkit::Popup *)jarg1;
82385   {
82386     try {
82387       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
82388     } catch (std::out_of_range& e) {
82389       {
82390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82391       };
82392     } catch (std::exception& e) {
82393       {
82394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82395       };
82396     } catch (...) {
82397       {
82398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82399       };
82400     }
82401   }
82402   jresult = (void *)result;
82403   return jresult;
82404 }
82405
82406
82407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
82408   int jresult ;
82409   int result;
82410
82411   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
82412   jresult = (int)result;
82413   return jresult;
82414 }
82415
82416
82417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
82418   int jresult ;
82419   int result;
82420
82421   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
82422   jresult = (int)result;
82423   return jresult;
82424 }
82425
82426
82427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
82428   int jresult ;
82429   int result;
82430
82431   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
82432   jresult = (int)result;
82433   return jresult;
82434 }
82435
82436
82437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
82438   int jresult ;
82439   int result;
82440
82441   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
82442   jresult = (int)result;
82443   return jresult;
82444 }
82445
82446
82447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
82448   int jresult ;
82449   int result;
82450
82451   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
82452   jresult = (int)result;
82453   return jresult;
82454 }
82455
82456
82457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
82458   int jresult ;
82459   int result;
82460
82461   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
82462   jresult = (int)result;
82463   return jresult;
82464 }
82465
82466
82467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
82468   int jresult ;
82469   int result;
82470
82471   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
82472   jresult = (int)result;
82473   return jresult;
82474 }
82475
82476
82477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
82478   int jresult ;
82479   int result;
82480
82481   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
82482   jresult = (int)result;
82483   return jresult;
82484 }
82485
82486
82487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
82488   int jresult ;
82489   int result;
82490
82491   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
82492   jresult = (int)result;
82493   return jresult;
82494 }
82495
82496
82497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
82498   void * jresult ;
82499   Dali::Toolkit::ProgressBar::Property *result = 0 ;
82500
82501   {
82502     try {
82503       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
82504     } catch (std::out_of_range& e) {
82505       {
82506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82507       };
82508     } catch (std::exception& e) {
82509       {
82510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82511       };
82512     } catch (...) {
82513       {
82514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82515       };
82516     }
82517   }
82518   jresult = (void *)result;
82519   return jresult;
82520 }
82521
82522
82523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
82524   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
82525
82526   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
82527   {
82528     try {
82529       delete arg1;
82530     } catch (std::out_of_range& e) {
82531       {
82532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82533       };
82534     } catch (std::exception& e) {
82535       {
82536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82537       };
82538     } catch (...) {
82539       {
82540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82541       };
82542     }
82543   }
82544 }
82545
82546
82547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
82548   void * jresult ;
82549   Dali::Toolkit::ProgressBar result;
82550
82551   {
82552     try {
82553       result = Dali::Toolkit::ProgressBar::New();
82554     } catch (std::out_of_range& e) {
82555       {
82556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82557       };
82558     } catch (std::exception& e) {
82559       {
82560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82561       };
82562     } catch (...) {
82563       {
82564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82565       };
82566     }
82567   }
82568   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82569   return jresult;
82570 }
82571
82572
82573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
82574   void * jresult ;
82575   Dali::Toolkit::ProgressBar *result = 0 ;
82576
82577   {
82578     try {
82579       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
82580     } catch (std::out_of_range& e) {
82581       {
82582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82583       };
82584     } catch (std::exception& e) {
82585       {
82586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82587       };
82588     } catch (...) {
82589       {
82590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82591       };
82592     }
82593   }
82594   jresult = (void *)result;
82595   return jresult;
82596 }
82597
82598
82599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
82600   void * jresult ;
82601   Dali::Toolkit::ProgressBar *arg1 = 0 ;
82602   Dali::Toolkit::ProgressBar *result = 0 ;
82603
82604   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82605   if (!arg1) {
82606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82607     return 0;
82608   }
82609   {
82610     try {
82611       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
82612     } catch (std::out_of_range& e) {
82613       {
82614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82615       };
82616     } catch (std::exception& e) {
82617       {
82618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82619       };
82620     } catch (...) {
82621       {
82622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82623       };
82624     }
82625   }
82626   jresult = (void *)result;
82627   return jresult;
82628 }
82629
82630
82631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
82632   void * jresult ;
82633   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82634   Dali::Toolkit::ProgressBar *arg2 = 0 ;
82635   Dali::Toolkit::ProgressBar *result = 0 ;
82636
82637   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82638   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
82639   if (!arg2) {
82640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82641     return 0;
82642   }
82643   {
82644     try {
82645       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
82646     } catch (std::out_of_range& e) {
82647       {
82648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82649       };
82650     } catch (std::exception& e) {
82651       {
82652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82653       };
82654     } catch (...) {
82655       {
82656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82657       };
82658     }
82659   }
82660   jresult = (void *)result;
82661   return jresult;
82662 }
82663
82664
82665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
82666   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82667
82668   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82669   {
82670     try {
82671       delete arg1;
82672     } catch (std::out_of_range& e) {
82673       {
82674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82675       };
82676     } catch (std::exception& e) {
82677       {
82678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82679       };
82680     } catch (...) {
82681       {
82682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82683       };
82684     }
82685   }
82686 }
82687
82688
82689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
82690   void * jresult ;
82691   Dali::BaseHandle arg1 ;
82692   Dali::BaseHandle *argp1 ;
82693   Dali::Toolkit::ProgressBar result;
82694
82695   argp1 = (Dali::BaseHandle *)jarg1;
82696   if (!argp1) {
82697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82698     return 0;
82699   }
82700   arg1 = *argp1;
82701   {
82702     try {
82703       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
82704     } catch (std::out_of_range& e) {
82705       {
82706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82707       };
82708     } catch (std::exception& e) {
82709       {
82710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82711       };
82712     } catch (...) {
82713       {
82714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82715       };
82716     }
82717   }
82718   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82719   return jresult;
82720 }
82721
82722
82723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
82724   void * jresult ;
82725   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82726   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
82727
82728   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82729   {
82730     try {
82731       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
82732     } catch (std::out_of_range& e) {
82733       {
82734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82735       };
82736     } catch (std::exception& e) {
82737       {
82738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82739       };
82740     } catch (...) {
82741       {
82742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82743       };
82744     }
82745   }
82746   jresult = (void *)result;
82747   return jresult;
82748 }
82749
82750
82751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
82752   void * jresult ;
82753   Dali::Toolkit::GaussianBlurView *result = 0 ;
82754
82755   {
82756     try {
82757       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
82758     } catch (std::out_of_range& e) {
82759       {
82760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82761       };
82762     } catch (std::exception& e) {
82763       {
82764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82765       };
82766     } catch (...) {
82767       {
82768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82769       };
82770     }
82771   }
82772   jresult = (void *)result;
82773   return jresult;
82774 }
82775
82776
82777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
82778   void * jresult ;
82779   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
82780   Dali::Toolkit::GaussianBlurView *result = 0 ;
82781
82782   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82783   if (!arg1) {
82784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
82785     return 0;
82786   }
82787   {
82788     try {
82789       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
82790     } catch (std::out_of_range& e) {
82791       {
82792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82793       };
82794     } catch (std::exception& e) {
82795       {
82796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82797       };
82798     } catch (...) {
82799       {
82800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82801       };
82802     }
82803   }
82804   jresult = (void *)result;
82805   return jresult;
82806 }
82807
82808
82809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
82810   void * jresult ;
82811   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82812   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
82813   Dali::Toolkit::GaussianBlurView *result = 0 ;
82814
82815   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82816   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
82817   if (!arg2) {
82818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
82819     return 0;
82820   }
82821   {
82822     try {
82823       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
82824     } catch (std::out_of_range& e) {
82825       {
82826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82827       };
82828     } catch (std::exception& e) {
82829       {
82830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82831       };
82832     } catch (...) {
82833       {
82834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82835       };
82836     }
82837   }
82838   jresult = (void *)result;
82839   return jresult;
82840 }
82841
82842
82843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
82844   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82845
82846   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82847   {
82848     try {
82849       delete arg1;
82850     } catch (std::out_of_range& e) {
82851       {
82852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82853       };
82854     } catch (std::exception& e) {
82855       {
82856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82857       };
82858     } catch (...) {
82859       {
82860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82861       };
82862     }
82863   }
82864 }
82865
82866
82867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
82868   void * jresult ;
82869   Dali::BaseHandle arg1 ;
82870   Dali::BaseHandle *argp1 ;
82871   Dali::Toolkit::GaussianBlurView result;
82872
82873   argp1 = (Dali::BaseHandle *)jarg1;
82874   if (!argp1) {
82875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82876     return 0;
82877   }
82878   arg1 = *argp1;
82879   {
82880     try {
82881       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
82882     } catch (std::out_of_range& e) {
82883       {
82884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82885       };
82886     } catch (std::exception& e) {
82887       {
82888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82889       };
82890     } catch (...) {
82891       {
82892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82893       };
82894     }
82895   }
82896   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82897   return jresult;
82898 }
82899
82900
82901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
82902   void * jresult ;
82903   Dali::Toolkit::GaussianBlurView result;
82904
82905   {
82906     try {
82907       result = Dali::Toolkit::GaussianBlurView::New();
82908     } catch (std::out_of_range& e) {
82909       {
82910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82911       };
82912     } catch (std::exception& e) {
82913       {
82914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82915       };
82916     } catch (...) {
82917       {
82918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82919       };
82920     }
82921   }
82922   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82923   return jresult;
82924 }
82925
82926
82927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
82928   void * jresult ;
82929   unsigned int arg1 ;
82930   float arg2 ;
82931   Dali::Pixel::Format arg3 ;
82932   float arg4 ;
82933   float arg5 ;
82934   bool arg6 ;
82935   Dali::Toolkit::GaussianBlurView result;
82936
82937   arg1 = (unsigned int)jarg1;
82938   arg2 = (float)jarg2;
82939   arg3 = (Dali::Pixel::Format)jarg3;
82940   arg4 = (float)jarg4;
82941   arg5 = (float)jarg5;
82942   arg6 = jarg6 ? true : false;
82943   {
82944     try {
82945       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
82946     } catch (std::out_of_range& e) {
82947       {
82948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82949       };
82950     } catch (std::exception& e) {
82951       {
82952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82953       };
82954     } catch (...) {
82955       {
82956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82957       };
82958     }
82959   }
82960   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82961   return jresult;
82962 }
82963
82964
82965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
82966   void * jresult ;
82967   unsigned int arg1 ;
82968   float arg2 ;
82969   Dali::Pixel::Format arg3 ;
82970   float arg4 ;
82971   float arg5 ;
82972   Dali::Toolkit::GaussianBlurView result;
82973
82974   arg1 = (unsigned int)jarg1;
82975   arg2 = (float)jarg2;
82976   arg3 = (Dali::Pixel::Format)jarg3;
82977   arg4 = (float)jarg4;
82978   arg5 = (float)jarg5;
82979   {
82980     try {
82981       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
82982     } catch (std::out_of_range& e) {
82983       {
82984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82985       };
82986     } catch (std::exception& e) {
82987       {
82988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82989       };
82990     } catch (...) {
82991       {
82992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82993       };
82994     }
82995   }
82996   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82997   return jresult;
82998 }
82999
83000
83001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
83002   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83003   Dali::Actor arg2 ;
83004   Dali::Actor *argp2 ;
83005
83006   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83007   argp2 = (Dali::Actor *)jarg2;
83008   if (!argp2) {
83009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83010     return ;
83011   }
83012   arg2 = *argp2;
83013   {
83014     try {
83015       (arg1)->Add(arg2);
83016     } catch (std::out_of_range& e) {
83017       {
83018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83019       };
83020     } catch (std::exception& e) {
83021       {
83022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83023       };
83024     } catch (...) {
83025       {
83026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83027       };
83028     }
83029   }
83030 }
83031
83032
83033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
83034   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83035   Dali::Actor arg2 ;
83036   Dali::Actor *argp2 ;
83037
83038   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83039   argp2 = (Dali::Actor *)jarg2;
83040   if (!argp2) {
83041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83042     return ;
83043   }
83044   arg2 = *argp2;
83045   {
83046     try {
83047       (arg1)->Remove(arg2);
83048     } catch (std::out_of_range& e) {
83049       {
83050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83051       };
83052     } catch (std::exception& e) {
83053       {
83054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83055       };
83056     } catch (...) {
83057       {
83058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83059       };
83060     }
83061   }
83062 }
83063
83064
83065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
83066   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83067
83068   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83069   {
83070     try {
83071       (arg1)->Activate();
83072     } catch (std::out_of_range& e) {
83073       {
83074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83075       };
83076     } catch (std::exception& e) {
83077       {
83078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83079       };
83080     } catch (...) {
83081       {
83082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83083       };
83084     }
83085   }
83086 }
83087
83088
83089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
83090   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83091
83092   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83093   {
83094     try {
83095       (arg1)->ActivateOnce();
83096     } catch (std::out_of_range& e) {
83097       {
83098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83099       };
83100     } catch (std::exception& e) {
83101       {
83102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83103       };
83104     } catch (...) {
83105       {
83106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83107       };
83108     }
83109   }
83110 }
83111
83112
83113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
83114   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83115
83116   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83117   {
83118     try {
83119       (arg1)->Deactivate();
83120     } catch (std::out_of_range& e) {
83121       {
83122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83123       };
83124     } catch (std::exception& e) {
83125       {
83126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83127       };
83128     } catch (...) {
83129       {
83130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83131       };
83132     }
83133   }
83134 }
83135
83136
83137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
83138   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83139   Dali::Image arg2 ;
83140   Dali::FrameBufferImage arg3 ;
83141   Dali::Image *argp2 ;
83142   Dali::FrameBufferImage *argp3 ;
83143
83144   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83145   argp2 = (Dali::Image *)jarg2;
83146   if (!argp2) {
83147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
83148     return ;
83149   }
83150   arg2 = *argp2;
83151   argp3 = (Dali::FrameBufferImage *)jarg3;
83152   if (!argp3) {
83153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
83154     return ;
83155   }
83156   arg3 = *argp3;
83157   {
83158     try {
83159       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
83160     } catch (std::out_of_range& e) {
83161       {
83162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83163       };
83164     } catch (std::exception& e) {
83165       {
83166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83167       };
83168     } catch (...) {
83169       {
83170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83171       };
83172     }
83173   }
83174 }
83175
83176
83177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
83178   int jresult ;
83179   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83180   Dali::Property::Index result;
83181
83182   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83183   {
83184     try {
83185       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
83186     } catch (std::out_of_range& e) {
83187       {
83188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83189       };
83190     } catch (std::exception& e) {
83191       {
83192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83193       };
83194     } catch (...) {
83195       {
83196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83197       };
83198     }
83199   }
83200   jresult = result;
83201   return jresult;
83202 }
83203
83204
83205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
83206   void * jresult ;
83207   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83208   Dali::FrameBufferImage result;
83209
83210   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83211   {
83212     try {
83213       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
83214     } catch (std::out_of_range& e) {
83215       {
83216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83217       };
83218     } catch (std::exception& e) {
83219       {
83220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83221       };
83222     } catch (...) {
83223       {
83224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83225       };
83226     }
83227   }
83228   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
83229   return jresult;
83230 }
83231
83232
83233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
83234   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83235   Dali::Vector4 *arg2 = 0 ;
83236
83237   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83238   arg2 = (Dali::Vector4 *)jarg2;
83239   if (!arg2) {
83240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
83241     return ;
83242   }
83243   {
83244     try {
83245       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
83246     } catch (std::out_of_range& e) {
83247       {
83248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83249       };
83250     } catch (std::exception& e) {
83251       {
83252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83253       };
83254     } catch (...) {
83255       {
83256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83257       };
83258     }
83259   }
83260 }
83261
83262
83263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
83264   void * jresult ;
83265   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83266   Dali::Vector4 result;
83267
83268   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83269   {
83270     try {
83271       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
83272     } catch (std::out_of_range& e) {
83273       {
83274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83275       };
83276     } catch (std::exception& e) {
83277       {
83278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83279       };
83280     } catch (...) {
83281       {
83282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83283       };
83284     }
83285   }
83286   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
83287   return jresult;
83288 }
83289
83290
83291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
83292   void * jresult ;
83293   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83294   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
83295
83296   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83297   {
83298     try {
83299       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
83300     } catch (std::out_of_range& e) {
83301       {
83302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83303       };
83304     } catch (std::exception& e) {
83305       {
83306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83307       };
83308     } catch (...) {
83309       {
83310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83311       };
83312     }
83313   }
83314   jresult = (void *)result;
83315   return jresult;
83316 }
83317
83318
83319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
83320   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83321
83322   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83323   {
83324     try {
83325       delete arg1;
83326     } catch (std::out_of_range& e) {
83327       {
83328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83329       };
83330     } catch (std::exception& e) {
83331       {
83332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83333       };
83334     } catch (...) {
83335       {
83336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83337       };
83338     }
83339   }
83340 }
83341
83342
83343 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
83344   unsigned int jresult ;
83345   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83346   unsigned int result;
83347
83348   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83349   {
83350     try {
83351       result = (unsigned int)(arg1)->GetNumberOfPages();
83352     } catch (std::out_of_range& e) {
83353       {
83354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83355       };
83356     } catch (std::exception& e) {
83357       {
83358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83359       };
83360     } catch (...) {
83361       {
83362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83363       };
83364     }
83365   }
83366   jresult = result;
83367   return jresult;
83368 }
83369
83370
83371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
83372   void * jresult ;
83373   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83374   unsigned int arg2 ;
83375   Dali::Texture result;
83376
83377   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83378   arg2 = (unsigned int)jarg2;
83379   {
83380     try {
83381       result = (arg1)->NewPage(arg2);
83382     } catch (std::out_of_range& e) {
83383       {
83384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83385       };
83386     } catch (std::exception& e) {
83387       {
83388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83389       };
83390     } catch (...) {
83391       {
83392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83393       };
83394     }
83395   }
83396   jresult = new Dali::Texture((const Dali::Texture &)result);
83397   return jresult;
83398 }
83399
83400
83401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
83402   int jresult ;
83403   int result;
83404
83405   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
83406   jresult = (int)result;
83407   return jresult;
83408 }
83409
83410
83411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
83412   int jresult ;
83413   int result;
83414
83415   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
83416   jresult = (int)result;
83417   return jresult;
83418 }
83419
83420
83421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
83422   int jresult ;
83423   int result;
83424
83425   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
83426   jresult = (int)result;
83427   return jresult;
83428 }
83429
83430
83431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
83432   void * jresult ;
83433   Dali::Toolkit::PageTurnView::Property *result = 0 ;
83434
83435   {
83436     try {
83437       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
83438     } catch (std::out_of_range& e) {
83439       {
83440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83441       };
83442     } catch (std::exception& e) {
83443       {
83444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83445       };
83446     } catch (...) {
83447       {
83448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83449       };
83450     }
83451   }
83452   jresult = (void *)result;
83453   return jresult;
83454 }
83455
83456
83457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
83458   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
83459
83460   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
83461   {
83462     try {
83463       delete arg1;
83464     } catch (std::out_of_range& e) {
83465       {
83466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83467       };
83468     } catch (std::exception& e) {
83469       {
83470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83471       };
83472     } catch (...) {
83473       {
83474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83475       };
83476     }
83477   }
83478 }
83479
83480
83481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
83482   void * jresult ;
83483   Dali::Toolkit::PageTurnView *result = 0 ;
83484
83485   {
83486     try {
83487       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
83488     } catch (std::out_of_range& e) {
83489       {
83490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83491       };
83492     } catch (std::exception& e) {
83493       {
83494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83495       };
83496     } catch (...) {
83497       {
83498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83499       };
83500     }
83501   }
83502   jresult = (void *)result;
83503   return jresult;
83504 }
83505
83506
83507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
83508   void * jresult ;
83509   Dali::Toolkit::PageTurnView *arg1 = 0 ;
83510   Dali::Toolkit::PageTurnView *result = 0 ;
83511
83512   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83513   if (!arg1) {
83514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83515     return 0;
83516   }
83517   {
83518     try {
83519       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
83520     } catch (std::out_of_range& e) {
83521       {
83522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83523       };
83524     } catch (std::exception& e) {
83525       {
83526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83527       };
83528     } catch (...) {
83529       {
83530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83531       };
83532     }
83533   }
83534   jresult = (void *)result;
83535   return jresult;
83536 }
83537
83538
83539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
83540   void * jresult ;
83541   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83542   Dali::Toolkit::PageTurnView *arg2 = 0 ;
83543   Dali::Toolkit::PageTurnView *result = 0 ;
83544
83545   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83546   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
83547   if (!arg2) {
83548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83549     return 0;
83550   }
83551   {
83552     try {
83553       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
83554     } catch (std::out_of_range& e) {
83555       {
83556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83557       };
83558     } catch (std::exception& e) {
83559       {
83560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83561       };
83562     } catch (...) {
83563       {
83564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83565       };
83566     }
83567   }
83568   jresult = (void *)result;
83569   return jresult;
83570 }
83571
83572
83573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
83574   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83575
83576   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83577   {
83578     try {
83579       delete arg1;
83580     } catch (std::out_of_range& e) {
83581       {
83582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83583       };
83584     } catch (std::exception& e) {
83585       {
83586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83587       };
83588     } catch (...) {
83589       {
83590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83591       };
83592     }
83593   }
83594 }
83595
83596
83597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
83598   void * jresult ;
83599   Dali::BaseHandle arg1 ;
83600   Dali::BaseHandle *argp1 ;
83601   Dali::Toolkit::PageTurnView result;
83602
83603   argp1 = (Dali::BaseHandle *)jarg1;
83604   if (!argp1) {
83605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83606     return 0;
83607   }
83608   arg1 = *argp1;
83609   {
83610     try {
83611       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
83612     } catch (std::out_of_range& e) {
83613       {
83614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83615       };
83616     } catch (std::exception& e) {
83617       {
83618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83619       };
83620     } catch (...) {
83621       {
83622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83623       };
83624     }
83625   }
83626   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
83627   return jresult;
83628 }
83629
83630
83631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
83632   void * jresult ;
83633   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83634   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83635
83636   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83637   {
83638     try {
83639       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
83640     } catch (std::out_of_range& e) {
83641       {
83642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83643       };
83644     } catch (std::exception& e) {
83645       {
83646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83647       };
83648     } catch (...) {
83649       {
83650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83651       };
83652     }
83653   }
83654   jresult = (void *)result;
83655   return jresult;
83656 }
83657
83658
83659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
83660   void * jresult ;
83661   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83662   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83663
83664   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83665   {
83666     try {
83667       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
83668     } catch (std::out_of_range& e) {
83669       {
83670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83671       };
83672     } catch (std::exception& e) {
83673       {
83674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83675       };
83676     } catch (...) {
83677       {
83678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83679       };
83680     }
83681   }
83682   jresult = (void *)result;
83683   return jresult;
83684 }
83685
83686
83687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
83688   void * jresult ;
83689   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83690   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83691
83692   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83693   {
83694     try {
83695       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
83696     } catch (std::out_of_range& e) {
83697       {
83698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83699       };
83700     } catch (std::exception& e) {
83701       {
83702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83703       };
83704     } catch (...) {
83705       {
83706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83707       };
83708     }
83709   }
83710   jresult = (void *)result;
83711   return jresult;
83712 }
83713
83714
83715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
83716   void * jresult ;
83717   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83718   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83719
83720   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83721   {
83722     try {
83723       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
83724     } catch (std::out_of_range& e) {
83725       {
83726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83727       };
83728     } catch (std::exception& e) {
83729       {
83730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83731       };
83732     } catch (...) {
83733       {
83734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83735       };
83736     }
83737   }
83738   jresult = (void *)result;
83739   return jresult;
83740 }
83741
83742
83743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
83744   void * jresult ;
83745   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83746
83747   {
83748     try {
83749       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
83750     } catch (std::out_of_range& e) {
83751       {
83752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83753       };
83754     } catch (std::exception& e) {
83755       {
83756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83757       };
83758     } catch (...) {
83759       {
83760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83761       };
83762     }
83763   }
83764   jresult = (void *)result;
83765   return jresult;
83766 }
83767
83768
83769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
83770   void * jresult ;
83771   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
83772   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83773
83774   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83775   if (!arg1) {
83776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
83777     return 0;
83778   }
83779   {
83780     try {
83781       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
83782     } catch (std::out_of_range& e) {
83783       {
83784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83785       };
83786     } catch (std::exception& e) {
83787       {
83788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83789       };
83790     } catch (...) {
83791       {
83792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83793       };
83794     }
83795   }
83796   jresult = (void *)result;
83797   return jresult;
83798 }
83799
83800
83801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
83802   void * jresult ;
83803   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
83804   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
83805   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83806
83807   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83808   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
83809   if (!arg2) {
83810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
83811     return 0;
83812   }
83813   {
83814     try {
83815       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
83816     } catch (std::out_of_range& e) {
83817       {
83818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83819       };
83820     } catch (std::exception& e) {
83821       {
83822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83823       };
83824     } catch (...) {
83825       {
83826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83827       };
83828     }
83829   }
83830   jresult = (void *)result;
83831   return jresult;
83832 }
83833
83834
83835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
83836   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
83837
83838   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83839   {
83840     try {
83841       delete arg1;
83842     } catch (std::out_of_range& e) {
83843       {
83844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83845       };
83846     } catch (std::exception& e) {
83847       {
83848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83849       };
83850     } catch (...) {
83851       {
83852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83853       };
83854     }
83855   }
83856 }
83857
83858
83859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
83860   void * jresult ;
83861   Dali::Toolkit::PageFactory *arg1 = 0 ;
83862   Dali::Vector2 *arg2 = 0 ;
83863   Dali::Toolkit::PageTurnLandscapeView result;
83864
83865   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83866   if (!arg1) {
83867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
83868     return 0;
83869   }
83870   arg2 = (Dali::Vector2 *)jarg2;
83871   if (!arg2) {
83872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
83873     return 0;
83874   }
83875   {
83876     try {
83877       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
83878     } catch (std::out_of_range& e) {
83879       {
83880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83881       };
83882     } catch (std::exception& e) {
83883       {
83884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83885       };
83886     } catch (...) {
83887       {
83888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83889       };
83890     }
83891   }
83892   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
83893   return jresult;
83894 }
83895
83896
83897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
83898   void * jresult ;
83899   Dali::BaseHandle arg1 ;
83900   Dali::BaseHandle *argp1 ;
83901   Dali::Toolkit::PageTurnLandscapeView result;
83902
83903   argp1 = (Dali::BaseHandle *)jarg1;
83904   if (!argp1) {
83905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83906     return 0;
83907   }
83908   arg1 = *argp1;
83909   {
83910     try {
83911       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
83912     } catch (std::out_of_range& e) {
83913       {
83914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83915       };
83916     } catch (std::exception& e) {
83917       {
83918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83919       };
83920     } catch (...) {
83921       {
83922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83923       };
83924     }
83925   }
83926   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
83927   return jresult;
83928 }
83929
83930
83931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
83932   void * jresult ;
83933   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83934
83935   {
83936     try {
83937       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
83938     } catch (std::out_of_range& e) {
83939       {
83940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83941       };
83942     } catch (std::exception& e) {
83943       {
83944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83945       };
83946     } catch (...) {
83947       {
83948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83949       };
83950     }
83951   }
83952   jresult = (void *)result;
83953   return jresult;
83954 }
83955
83956
83957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
83958   void * jresult ;
83959   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
83960   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83961
83962   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83963   if (!arg1) {
83964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
83965     return 0;
83966   }
83967   {
83968     try {
83969       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
83970     } catch (std::out_of_range& e) {
83971       {
83972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83973       };
83974     } catch (std::exception& e) {
83975       {
83976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83977       };
83978     } catch (...) {
83979       {
83980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83981       };
83982     }
83983   }
83984   jresult = (void *)result;
83985   return jresult;
83986 }
83987
83988
83989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
83990   void * jresult ;
83991   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
83992   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
83993   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83994
83995   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83996   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
83997   if (!arg2) {
83998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
83999     return 0;
84000   }
84001   {
84002     try {
84003       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
84004     } catch (std::out_of_range& e) {
84005       {
84006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84007       };
84008     } catch (std::exception& e) {
84009       {
84010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84011       };
84012     } catch (...) {
84013       {
84014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84015       };
84016     }
84017   }
84018   jresult = (void *)result;
84019   return jresult;
84020 }
84021
84022
84023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
84024   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
84025
84026   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84027   {
84028     try {
84029       delete arg1;
84030     } catch (std::out_of_range& e) {
84031       {
84032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84033       };
84034     } catch (std::exception& e) {
84035       {
84036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84037       };
84038     } catch (...) {
84039       {
84040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84041       };
84042     }
84043   }
84044 }
84045
84046
84047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
84048   void * jresult ;
84049   Dali::Toolkit::PageFactory *arg1 = 0 ;
84050   Dali::Vector2 *arg2 = 0 ;
84051   Dali::Toolkit::PageTurnPortraitView result;
84052
84053   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84054   if (!arg1) {
84055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84056     return 0;
84057   }
84058   arg2 = (Dali::Vector2 *)jarg2;
84059   if (!arg2) {
84060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84061     return 0;
84062   }
84063   {
84064     try {
84065       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
84066     } catch (std::out_of_range& e) {
84067       {
84068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84069       };
84070     } catch (std::exception& e) {
84071       {
84072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84073       };
84074     } catch (...) {
84075       {
84076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84077       };
84078     }
84079   }
84080   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
84081   return jresult;
84082 }
84083
84084
84085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
84086   void * jresult ;
84087   Dali::BaseHandle arg1 ;
84088   Dali::BaseHandle *argp1 ;
84089   Dali::Toolkit::PageTurnPortraitView result;
84090
84091   argp1 = (Dali::BaseHandle *)jarg1;
84092   if (!argp1) {
84093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84094     return 0;
84095   }
84096   arg1 = *argp1;
84097   {
84098     try {
84099       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
84100     } catch (std::out_of_range& e) {
84101       {
84102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84103       };
84104     } catch (std::exception& e) {
84105       {
84106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84107       };
84108     } catch (...) {
84109       {
84110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84111       };
84112     }
84113   }
84114   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
84115   return jresult;
84116 }
84117
84118
84119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
84120   int jresult ;
84121   int result;
84122
84123   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
84124   jresult = (int)result;
84125   return jresult;
84126 }
84127
84128
84129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
84130   int jresult ;
84131   int result;
84132
84133   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
84134   jresult = (int)result;
84135   return jresult;
84136 }
84137
84138
84139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
84140   int jresult ;
84141   int result;
84142
84143   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
84144   jresult = (int)result;
84145   return jresult;
84146 }
84147
84148
84149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
84150   void * jresult ;
84151   Dali::Toolkit::ToggleButton::Property *result = 0 ;
84152
84153   {
84154     try {
84155       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
84156     } catch (std::out_of_range& e) {
84157       {
84158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84159       };
84160     } catch (std::exception& e) {
84161       {
84162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84163       };
84164     } catch (...) {
84165       {
84166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84167       };
84168     }
84169   }
84170   jresult = (void *)result;
84171   return jresult;
84172 }
84173
84174
84175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
84176   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
84177
84178   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
84179   {
84180     try {
84181       delete arg1;
84182     } catch (std::out_of_range& e) {
84183       {
84184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84185       };
84186     } catch (std::exception& e) {
84187       {
84188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84189       };
84190     } catch (...) {
84191       {
84192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84193       };
84194     }
84195   }
84196 }
84197
84198
84199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
84200   void * jresult ;
84201   Dali::Toolkit::ToggleButton *result = 0 ;
84202
84203   {
84204     try {
84205       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
84206     } catch (std::out_of_range& e) {
84207       {
84208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84209       };
84210     } catch (std::exception& e) {
84211       {
84212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84213       };
84214     } catch (...) {
84215       {
84216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84217       };
84218     }
84219   }
84220   jresult = (void *)result;
84221   return jresult;
84222 }
84223
84224
84225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
84226   void * jresult ;
84227   Dali::Toolkit::ToggleButton *arg1 = 0 ;
84228   Dali::Toolkit::ToggleButton *result = 0 ;
84229
84230   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84231   if (!arg1) {
84232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
84233     return 0;
84234   }
84235   {
84236     try {
84237       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
84238     } catch (std::out_of_range& e) {
84239       {
84240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84241       };
84242     } catch (std::exception& e) {
84243       {
84244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84245       };
84246     } catch (...) {
84247       {
84248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84249       };
84250     }
84251   }
84252   jresult = (void *)result;
84253   return jresult;
84254 }
84255
84256
84257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
84258   void * jresult ;
84259   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
84260   Dali::Toolkit::ToggleButton *arg2 = 0 ;
84261   Dali::Toolkit::ToggleButton *result = 0 ;
84262
84263   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84264   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
84265   if (!arg2) {
84266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
84267     return 0;
84268   }
84269   {
84270     try {
84271       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
84272     } catch (std::out_of_range& e) {
84273       {
84274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84275       };
84276     } catch (std::exception& e) {
84277       {
84278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84279       };
84280     } catch (...) {
84281       {
84282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84283       };
84284     }
84285   }
84286   jresult = (void *)result;
84287   return jresult;
84288 }
84289
84290
84291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
84292   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
84293
84294   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84295   {
84296     try {
84297       delete arg1;
84298     } catch (std::out_of_range& e) {
84299       {
84300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84301       };
84302     } catch (std::exception& e) {
84303       {
84304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84305       };
84306     } catch (...) {
84307       {
84308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84309       };
84310     }
84311   }
84312 }
84313
84314
84315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
84316   void * jresult ;
84317   Dali::Toolkit::ToggleButton result;
84318
84319   {
84320     try {
84321       result = Dali::Toolkit::ToggleButton::New();
84322     } catch (std::out_of_range& e) {
84323       {
84324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84325       };
84326     } catch (std::exception& e) {
84327       {
84328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84329       };
84330     } catch (...) {
84331       {
84332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84333       };
84334     }
84335   }
84336   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
84337   return jresult;
84338 }
84339
84340
84341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
84342   void * jresult ;
84343   Dali::BaseHandle arg1 ;
84344   Dali::BaseHandle *argp1 ;
84345   Dali::Toolkit::ToggleButton result;
84346
84347   argp1 = (Dali::BaseHandle *)jarg1;
84348   if (!argp1) {
84349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84350     return 0;
84351   }
84352   arg1 = *argp1;
84353   {
84354     try {
84355       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
84356     } catch (std::out_of_range& e) {
84357       {
84358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84359       };
84360     } catch (std::exception& e) {
84361       {
84362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84363       };
84364     } catch (...) {
84365       {
84366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84367       };
84368     }
84369   }
84370   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
84371   return jresult;
84372 }
84373
84374
84375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
84376   void * jresult ;
84377   Dali::Toolkit::Visual::Base *result = 0 ;
84378
84379   {
84380     try {
84381       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
84382     } catch (std::out_of_range& e) {
84383       {
84384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84385       };
84386     } catch (std::exception& e) {
84387       {
84388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84389       };
84390     } catch (...) {
84391       {
84392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84393       };
84394     }
84395   }
84396   jresult = (void *)result;
84397   return jresult;
84398 }
84399
84400
84401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
84402   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84403
84404   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84405   {
84406     try {
84407       delete arg1;
84408     } catch (std::out_of_range& e) {
84409       {
84410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84411       };
84412     } catch (std::exception& e) {
84413       {
84414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84415       };
84416     } catch (...) {
84417       {
84418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84419       };
84420     }
84421   }
84422 }
84423
84424
84425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
84426   void * jresult ;
84427   Dali::Toolkit::Visual::Base *arg1 = 0 ;
84428   Dali::Toolkit::Visual::Base *result = 0 ;
84429
84430   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84431   if (!arg1) {
84432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84433     return 0;
84434   }
84435   {
84436     try {
84437       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
84438     } catch (std::out_of_range& e) {
84439       {
84440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84441       };
84442     } catch (std::exception& e) {
84443       {
84444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84445       };
84446     } catch (...) {
84447       {
84448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84449       };
84450     }
84451   }
84452   jresult = (void *)result;
84453   return jresult;
84454 }
84455
84456
84457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
84458   void * jresult ;
84459   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84460   Dali::Toolkit::Visual::Base *arg2 = 0 ;
84461   Dali::Toolkit::Visual::Base *result = 0 ;
84462
84463   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84464   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
84465   if (!arg2) {
84466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84467     return 0;
84468   }
84469   {
84470     try {
84471       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
84472     } catch (std::out_of_range& e) {
84473       {
84474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84475       };
84476     } catch (std::exception& e) {
84477       {
84478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84479       };
84480     } catch (...) {
84481       {
84482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84483       };
84484     }
84485   }
84486   jresult = (void *)result;
84487   return jresult;
84488 }
84489
84490
84491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
84492   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84493   std::string *arg2 = 0 ;
84494
84495   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84496   if (!jarg2) {
84497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84498     return ;
84499   }
84500   std::string arg2_str(jarg2);
84501   arg2 = &arg2_str;
84502   {
84503     try {
84504       (arg1)->SetName((std::string const &)*arg2);
84505     } catch (std::out_of_range& e) {
84506       {
84507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84508       };
84509     } catch (std::exception& e) {
84510       {
84511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84512       };
84513     } catch (...) {
84514       {
84515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84516       };
84517     }
84518   }
84519
84520   //argout typemap for const std::string&
84521
84522 }
84523
84524
84525 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
84526   char * jresult ;
84527   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84528   std::string *result = 0 ;
84529
84530   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84531   {
84532     try {
84533       result = (std::string *) &(arg1)->GetName();
84534     } catch (std::out_of_range& e) {
84535       {
84536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84537       };
84538     } catch (std::exception& e) {
84539       {
84540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84541       };
84542     } catch (...) {
84543       {
84544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84545       };
84546     }
84547   }
84548   jresult = SWIG_csharp_string_callback(result->c_str());
84549   return jresult;
84550 }
84551
84552
84553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
84554   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84555   Dali::Property::Map *arg2 = 0 ;
84556   Dali::Size arg3 ;
84557   Dali::Size *argp3 ;
84558
84559   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84560   arg2 = (Dali::Property::Map *)jarg2;
84561   if (!arg2) {
84562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84563     return ;
84564   }
84565   argp3 = (Dali::Size *)jarg3;
84566   if (!argp3) {
84567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
84568     return ;
84569   }
84570   arg3 = *argp3;
84571   {
84572     try {
84573       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
84574     } catch (std::out_of_range& e) {
84575       {
84576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84577       };
84578     } catch (std::exception& e) {
84579       {
84580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84581       };
84582     } catch (...) {
84583       {
84584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84585       };
84586     }
84587   }
84588 }
84589
84590
84591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
84592   float jresult ;
84593   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84594   float arg2 ;
84595   float result;
84596
84597   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84598   arg2 = (float)jarg2;
84599   {
84600     try {
84601       result = (float)(arg1)->GetHeightForWidth(arg2);
84602     } catch (std::out_of_range& e) {
84603       {
84604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84605       };
84606     } catch (std::exception& e) {
84607       {
84608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84609       };
84610     } catch (...) {
84611       {
84612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84613       };
84614     }
84615   }
84616   jresult = result;
84617   return jresult;
84618 }
84619
84620
84621 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
84622   float jresult ;
84623   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84624   float arg2 ;
84625   float result;
84626
84627   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84628   arg2 = (float)jarg2;
84629   {
84630     try {
84631       result = (float)(arg1)->GetWidthForHeight(arg2);
84632     } catch (std::out_of_range& e) {
84633       {
84634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84635       };
84636     } catch (std::exception& e) {
84637       {
84638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84639       };
84640     } catch (...) {
84641       {
84642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84643       };
84644     }
84645   }
84646   jresult = result;
84647   return jresult;
84648 }
84649
84650
84651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
84652   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84653   Dali::Vector2 *arg2 = 0 ;
84654
84655   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84656   arg2 = (Dali::Vector2 *)jarg2;
84657   if (!arg2) {
84658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
84659     return ;
84660   }
84661   {
84662     try {
84663       (arg1)->GetNaturalSize(*arg2);
84664     } catch (std::out_of_range& e) {
84665       {
84666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84667       };
84668     } catch (std::exception& e) {
84669       {
84670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84671       };
84672     } catch (...) {
84673       {
84674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84675       };
84676     }
84677   }
84678 }
84679
84680
84681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
84682   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84683   float arg2 ;
84684
84685   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84686   arg2 = (float)jarg2;
84687   {
84688     try {
84689       (arg1)->SetDepthIndex(arg2);
84690     } catch (std::out_of_range& e) {
84691       {
84692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84693       };
84694     } catch (std::exception& e) {
84695       {
84696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84697       };
84698     } catch (...) {
84699       {
84700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84701       };
84702     }
84703   }
84704 }
84705
84706
84707 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
84708   float jresult ;
84709   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84710   float result;
84711
84712   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84713   {
84714     try {
84715       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
84716     } catch (std::out_of_range& e) {
84717       {
84718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84719       };
84720     } catch (std::exception& e) {
84721       {
84722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84723       };
84724     } catch (...) {
84725       {
84726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84727       };
84728     }
84729   }
84730   jresult = result;
84731   return jresult;
84732 }
84733
84734
84735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
84736   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84737   Dali::Property::Map *arg2 = 0 ;
84738
84739   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84740   arg2 = (Dali::Property::Map *)jarg2;
84741   if (!arg2) {
84742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
84743     return ;
84744   }
84745   {
84746     try {
84747       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
84748     } catch (std::out_of_range& e) {
84749       {
84750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84751       };
84752     } catch (std::exception& e) {
84753       {
84754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84755       };
84756     } catch (...) {
84757       {
84758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84759       };
84760     }
84761   }
84762 }
84763
84764
84765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
84766   void * jresult ;
84767   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
84768   Dali::Toolkit::Visual::Base *result = 0 ;
84769
84770   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
84771   {
84772     try {
84773       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
84774     } catch (std::out_of_range& e) {
84775       {
84776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84777       };
84778     } catch (std::exception& e) {
84779       {
84780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84781       };
84782     } catch (...) {
84783       {
84784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84785       };
84786     }
84787   }
84788   jresult = (void *)result;
84789   return jresult;
84790 }
84791
84792
84793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
84794   void * jresult ;
84795   Dali::Toolkit::VisualFactory result;
84796
84797   {
84798     try {
84799       result = Dali::Toolkit::VisualFactory::Get();
84800     } catch (std::out_of_range& e) {
84801       {
84802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84803       };
84804     } catch (std::exception& e) {
84805       {
84806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84807       };
84808     } catch (...) {
84809       {
84810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84811       };
84812     }
84813   }
84814   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
84815   return jresult;
84816 }
84817
84818
84819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
84820   void * jresult ;
84821   Dali::Toolkit::VisualFactory *result = 0 ;
84822
84823   {
84824     try {
84825       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
84826     } catch (std::out_of_range& e) {
84827       {
84828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84829       };
84830     } catch (std::exception& e) {
84831       {
84832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84833       };
84834     } catch (...) {
84835       {
84836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84837       };
84838     }
84839   }
84840   jresult = (void *)result;
84841   return jresult;
84842 }
84843
84844
84845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
84846   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84847
84848   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84849   {
84850     try {
84851       delete arg1;
84852     } catch (std::out_of_range& e) {
84853       {
84854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84855       };
84856     } catch (std::exception& e) {
84857       {
84858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84859       };
84860     } catch (...) {
84861       {
84862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84863       };
84864     }
84865   }
84866 }
84867
84868
84869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
84870   void * jresult ;
84871   Dali::Toolkit::VisualFactory *arg1 = 0 ;
84872   Dali::Toolkit::VisualFactory *result = 0 ;
84873
84874   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84875   if (!arg1) {
84876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
84877     return 0;
84878   }
84879   {
84880     try {
84881       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
84882     } catch (std::out_of_range& e) {
84883       {
84884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84885       };
84886     } catch (std::exception& e) {
84887       {
84888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84889       };
84890     } catch (...) {
84891       {
84892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84893       };
84894     }
84895   }
84896   jresult = (void *)result;
84897   return jresult;
84898 }
84899
84900
84901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
84902   void * jresult ;
84903   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84904   Dali::Toolkit::VisualFactory *arg2 = 0 ;
84905   Dali::Toolkit::VisualFactory *result = 0 ;
84906
84907   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84908   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
84909   if (!arg2) {
84910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
84911     return 0;
84912   }
84913   {
84914     try {
84915       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
84916     } catch (std::out_of_range& e) {
84917       {
84918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84919       };
84920     } catch (std::exception& e) {
84921       {
84922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84923       };
84924     } catch (...) {
84925       {
84926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84927       };
84928     }
84929   }
84930   jresult = (void *)result;
84931   return jresult;
84932 }
84933
84934
84935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
84936   void * jresult ;
84937   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84938   Dali::Property::Map *arg2 = 0 ;
84939   Dali::Toolkit::Visual::Base result;
84940
84941   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84942   arg2 = (Dali::Property::Map *)jarg2;
84943   if (!arg2) {
84944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84945     return 0;
84946   }
84947   {
84948     try {
84949       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
84950     } catch (std::out_of_range& e) {
84951       {
84952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84953       };
84954     } catch (std::exception& e) {
84955       {
84956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84957       };
84958     } catch (...) {
84959       {
84960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84961       };
84962     }
84963   }
84964   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84965   return jresult;
84966 }
84967
84968
84969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
84970   void * jresult ;
84971   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84972   Dali::Image *arg2 = 0 ;
84973   Dali::Toolkit::Visual::Base result;
84974
84975   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84976   arg2 = (Dali::Image *)jarg2;
84977   if (!arg2) {
84978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
84979     return 0;
84980   }
84981   {
84982     try {
84983       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
84984     } catch (std::out_of_range& e) {
84985       {
84986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84987       };
84988     } catch (std::exception& e) {
84989       {
84990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84991       };
84992     } catch (...) {
84993       {
84994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84995       };
84996     }
84997   }
84998   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84999   return jresult;
85000 }
85001
85002
85003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
85004   void * jresult ;
85005   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85006   std::string *arg2 = 0 ;
85007   Dali::ImageDimensions arg3 ;
85008   Dali::ImageDimensions *argp3 ;
85009   Dali::Toolkit::Visual::Base result;
85010
85011   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85012   if (!jarg2) {
85013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85014     return 0;
85015   }
85016   std::string arg2_str(jarg2);
85017   arg2 = &arg2_str;
85018   argp3 = (Dali::ImageDimensions *)jarg3;
85019   if (!argp3) {
85020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85021     return 0;
85022   }
85023   arg3 = *argp3;
85024   {
85025     try {
85026       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
85027     } catch (std::out_of_range& e) {
85028       {
85029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85030       };
85031     } catch (std::exception& e) {
85032       {
85033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85034       };
85035     } catch (...) {
85036       {
85037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85038       };
85039     }
85040   }
85041   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85042
85043   //argout typemap for const std::string&
85044
85045   return jresult;
85046 }
85047
85048
85049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
85050   void * jresult ;
85051   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85052
85053   {
85054     try {
85055       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
85056     } catch (std::out_of_range& e) {
85057       {
85058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85059       };
85060     } catch (std::exception& e) {
85061       {
85062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85063       };
85064     } catch (...) {
85065       {
85066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85067       };
85068     }
85069   }
85070   jresult = (void *)result;
85071   return jresult;
85072 }
85073
85074
85075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
85076   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85077
85078   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85079   {
85080     try {
85081       delete arg1;
85082     } catch (std::out_of_range& e) {
85083       {
85084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85085       };
85086     } catch (std::exception& e) {
85087       {
85088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85089       };
85090     } catch (...) {
85091       {
85092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85093       };
85094     }
85095   }
85096 }
85097
85098
85099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
85100   void * jresult ;
85101   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
85102   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85103
85104   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85105   if (!arg1) {
85106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
85107     return 0;
85108   }
85109   {
85110     try {
85111       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
85112     } catch (std::out_of_range& e) {
85113       {
85114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85115       };
85116     } catch (std::exception& e) {
85117       {
85118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85119       };
85120     } catch (...) {
85121       {
85122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85123       };
85124     }
85125   }
85126   jresult = (void *)result;
85127   return jresult;
85128 }
85129
85130
85131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
85132   void * jresult ;
85133   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85134   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
85135   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85136
85137   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85138   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
85139   if (!arg2) {
85140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
85141     return 0;
85142   }
85143   {
85144     try {
85145       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
85146     } catch (std::out_of_range& e) {
85147       {
85148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85149       };
85150     } catch (std::exception& e) {
85151       {
85152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85153       };
85154     } catch (...) {
85155       {
85156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85157       };
85158     }
85159   }
85160   jresult = (void *)result;
85161   return jresult;
85162 }
85163
85164
85165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
85166   void * jresult ;
85167   Dali::Toolkit::AsyncImageLoader result;
85168
85169   {
85170     try {
85171       result = Dali::Toolkit::AsyncImageLoader::New();
85172     } catch (std::out_of_range& e) {
85173       {
85174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85175       };
85176     } catch (std::exception& e) {
85177       {
85178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85179       };
85180     } catch (...) {
85181       {
85182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85183       };
85184     }
85185   }
85186   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
85187   return jresult;
85188 }
85189
85190
85191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
85192   void * jresult ;
85193   Dali::BaseHandle arg1 ;
85194   Dali::BaseHandle *argp1 ;
85195   Dali::Toolkit::AsyncImageLoader result;
85196
85197   argp1 = (Dali::BaseHandle *)jarg1;
85198   if (!argp1) {
85199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85200     return 0;
85201   }
85202   arg1 = *argp1;
85203   {
85204     try {
85205       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
85206     } catch (std::out_of_range& e) {
85207       {
85208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85209       };
85210     } catch (std::exception& e) {
85211       {
85212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85213       };
85214     } catch (...) {
85215       {
85216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85217       };
85218     }
85219   }
85220   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
85221   return jresult;
85222 }
85223
85224
85225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
85226   unsigned int jresult ;
85227   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85228   std::string *arg2 = 0 ;
85229   uint32_t result;
85230
85231   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85232   if (!jarg2) {
85233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85234     return 0;
85235   }
85236   std::string arg2_str(jarg2);
85237   arg2 = &arg2_str;
85238   {
85239     try {
85240       result = (arg1)->Load((std::string const &)*arg2);
85241     } catch (std::out_of_range& e) {
85242       {
85243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85244       };
85245     } catch (std::exception& e) {
85246       {
85247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85248       };
85249     } catch (...) {
85250       {
85251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85252       };
85253     }
85254   }
85255   jresult = result;
85256
85257   //argout typemap for const std::string&
85258
85259   return jresult;
85260 }
85261
85262
85263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
85264   unsigned int jresult ;
85265   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85266   std::string *arg2 = 0 ;
85267   Dali::ImageDimensions arg3 ;
85268   Dali::ImageDimensions *argp3 ;
85269   uint32_t result;
85270
85271   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85272   if (!jarg2) {
85273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85274     return 0;
85275   }
85276   std::string arg2_str(jarg2);
85277   arg2 = &arg2_str;
85278   argp3 = (Dali::ImageDimensions *)jarg3;
85279   if (!argp3) {
85280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85281     return 0;
85282   }
85283   arg3 = *argp3;
85284   {
85285     try {
85286       result = (arg1)->Load((std::string const &)*arg2,arg3);
85287     } catch (std::out_of_range& e) {
85288       {
85289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85290       };
85291     } catch (std::exception& e) {
85292       {
85293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85294       };
85295     } catch (...) {
85296       {
85297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85298       };
85299     }
85300   }
85301   jresult = result;
85302
85303   //argout typemap for const std::string&
85304
85305   return jresult;
85306 }
85307
85308
85309 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
85310   unsigned int jresult ;
85311   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85312   std::string *arg2 = 0 ;
85313   Dali::ImageDimensions arg3 ;
85314   Dali::FittingMode::Type arg4 ;
85315   Dali::SamplingMode::Type arg5 ;
85316   bool arg6 ;
85317   Dali::ImageDimensions *argp3 ;
85318   uint32_t result;
85319
85320   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85321   if (!jarg2) {
85322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85323     return 0;
85324   }
85325   std::string arg2_str(jarg2);
85326   arg2 = &arg2_str;
85327   argp3 = (Dali::ImageDimensions *)jarg3;
85328   if (!argp3) {
85329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85330     return 0;
85331   }
85332   arg3 = *argp3;
85333   arg4 = (Dali::FittingMode::Type)jarg4;
85334   arg5 = (Dali::SamplingMode::Type)jarg5;
85335   arg6 = jarg6 ? true : false;
85336   {
85337     try {
85338       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
85339     } catch (std::out_of_range& e) {
85340       {
85341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85342       };
85343     } catch (std::exception& e) {
85344       {
85345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85346       };
85347     } catch (...) {
85348       {
85349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85350       };
85351     }
85352   }
85353   jresult = result;
85354
85355   //argout typemap for const std::string&
85356
85357   return jresult;
85358 }
85359
85360
85361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
85362   unsigned int jresult ;
85363   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85364   uint32_t arg2 ;
85365   bool result;
85366
85367   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85368   arg2 = (uint32_t)jarg2;
85369   {
85370     try {
85371       result = (bool)(arg1)->Cancel(arg2);
85372     } catch (std::out_of_range& e) {
85373       {
85374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85375       };
85376     } catch (std::exception& e) {
85377       {
85378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85379       };
85380     } catch (...) {
85381       {
85382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85383       };
85384     }
85385   }
85386   jresult = result;
85387   return jresult;
85388 }
85389
85390
85391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
85392   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85393
85394   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85395   {
85396     try {
85397       (arg1)->CancelAll();
85398     } catch (std::out_of_range& e) {
85399       {
85400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85401       };
85402     } catch (std::exception& e) {
85403       {
85404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85405       };
85406     } catch (...) {
85407       {
85408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85409       };
85410     }
85411   }
85412 }
85413
85414
85415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
85416   void * jresult ;
85417   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85418   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
85419
85420   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85421   {
85422     try {
85423       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
85424     } catch (std::out_of_range& e) {
85425       {
85426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85427       };
85428     } catch (std::exception& e) {
85429       {
85430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85431       };
85432     } catch (...) {
85433       {
85434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85435       };
85436     }
85437   }
85438   jresult = (void *)result;
85439   return jresult;
85440 }
85441
85442
85443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
85444   void * jresult ;
85445   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
85446   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85447
85448   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
85449   {
85450     try {
85451       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
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 = (void *)result;
85467   return jresult;
85468 }
85469
85470
85471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
85472   void * jresult ;
85473   std::string *arg1 = 0 ;
85474   Dali::PixelData result;
85475
85476   if (!jarg1) {
85477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85478     return 0;
85479   }
85480   std::string arg1_str(jarg1);
85481   arg1 = &arg1_str;
85482   {
85483     try {
85484       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
85485     } catch (std::out_of_range& e) {
85486       {
85487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85488       };
85489     } catch (std::exception& e) {
85490       {
85491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85492       };
85493     } catch (...) {
85494       {
85495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85496       };
85497     }
85498   }
85499   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85500
85501   //argout typemap for const std::string&
85502
85503   return jresult;
85504 }
85505
85506
85507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
85508   void * jresult ;
85509   std::string *arg1 = 0 ;
85510   Dali::ImageDimensions arg2 ;
85511   Dali::ImageDimensions *argp2 ;
85512   Dali::PixelData result;
85513
85514   if (!jarg1) {
85515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85516     return 0;
85517   }
85518   std::string arg1_str(jarg1);
85519   arg1 = &arg1_str;
85520   argp2 = (Dali::ImageDimensions *)jarg2;
85521   if (!argp2) {
85522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85523     return 0;
85524   }
85525   arg2 = *argp2;
85526   {
85527     try {
85528       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
85529     } catch (std::out_of_range& e) {
85530       {
85531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85532       };
85533     } catch (std::exception& e) {
85534       {
85535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85536       };
85537     } catch (...) {
85538       {
85539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85540       };
85541     }
85542   }
85543   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85544
85545   //argout typemap for const std::string&
85546
85547   return jresult;
85548 }
85549
85550
85551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
85552   void * jresult ;
85553   std::string *arg1 = 0 ;
85554   Dali::ImageDimensions arg2 ;
85555   Dali::FittingMode::Type arg3 ;
85556   Dali::SamplingMode::Type arg4 ;
85557   bool arg5 ;
85558   Dali::ImageDimensions *argp2 ;
85559   Dali::PixelData result;
85560
85561   if (!jarg1) {
85562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85563     return 0;
85564   }
85565   std::string arg1_str(jarg1);
85566   arg1 = &arg1_str;
85567   argp2 = (Dali::ImageDimensions *)jarg2;
85568   if (!argp2) {
85569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85570     return 0;
85571   }
85572   arg2 = *argp2;
85573   arg3 = (Dali::FittingMode::Type)jarg3;
85574   arg4 = (Dali::SamplingMode::Type)jarg4;
85575   arg5 = jarg5 ? true : false;
85576   {
85577     try {
85578       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
85579     } catch (std::out_of_range& e) {
85580       {
85581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85582       };
85583     } catch (std::exception& e) {
85584       {
85585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85586       };
85587     } catch (...) {
85588       {
85589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85590       };
85591     }
85592   }
85593   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85594
85595   //argout typemap for const std::string&
85596
85597   return jresult;
85598 }
85599
85600
85601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
85602   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
85603
85604   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
85605   {
85606     try {
85607       delete arg1;
85608     } catch (std::out_of_range& e) {
85609       {
85610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85611       };
85612     } catch (std::exception& e) {
85613       {
85614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85615       };
85616     } catch (...) {
85617       {
85618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85619       };
85620     }
85621   }
85622 }
85623
85624
85625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
85626   void * jresult ;
85627   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
85628   Dali::Actor arg2 ;
85629   Dali::Actor arg3 ;
85630   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
85631   Dali::Actor *argp2 ;
85632   Dali::Actor *argp3 ;
85633   Dali::Actor result;
85634
85635   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
85636   argp2 = (Dali::Actor *)jarg2;
85637   if (!argp2) {
85638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85639     return 0;
85640   }
85641   arg2 = *argp2;
85642   argp3 = (Dali::Actor *)jarg3;
85643   if (!argp3) {
85644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85645     return 0;
85646   }
85647   arg3 = *argp3;
85648   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
85649   {
85650     try {
85651       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
85652     } catch (std::out_of_range& e) {
85653       {
85654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85655       };
85656     } catch (std::exception& e) {
85657       {
85658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85659       };
85660     } catch (...) {
85661       {
85662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85663       };
85664     }
85665   }
85666   jresult = new Dali::Actor((const Dali::Actor &)result);
85667   return jresult;
85668 }
85669
85670
85671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
85672   void * jresult ;
85673   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
85674
85675   {
85676     try {
85677       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
85678     } catch (std::out_of_range& e) {
85679       {
85680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85681       };
85682     } catch (std::exception& e) {
85683       {
85684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85685       };
85686     } catch (...) {
85687       {
85688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85689       };
85690     }
85691   }
85692   jresult = (void *)result;
85693   return jresult;
85694 }
85695
85696
85697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
85698   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
85699   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
85700   if (director) {
85701     director->swig_connect_director(callback0);
85702   }
85703 }
85704
85705
85706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
85707   KeyboardFocusManager arg1 ;
85708   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
85709   KeyboardFocusManager *argp1 ;
85710
85711   argp1 = (KeyboardFocusManager *)jarg1;
85712   if (!argp1) {
85713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
85714     return ;
85715   }
85716   arg1 = *argp1;
85717   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
85718   if (!arg2) {
85719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
85720     return ;
85721   }
85722   {
85723     try {
85724       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
85725     } catch (std::out_of_range& e) {
85726       {
85727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85728       };
85729     } catch (std::exception& e) {
85730       {
85731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85732       };
85733     } catch (...) {
85734       {
85735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85736       };
85737     }
85738   }
85739 }
85740
85741
85742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
85743   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85744
85745   arg1 = (std::vector< unsigned int > *)jarg1;
85746   {
85747     try {
85748       (arg1)->clear();
85749     } catch (std::out_of_range& e) {
85750       {
85751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85752       };
85753     } catch (std::exception& e) {
85754       {
85755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85756       };
85757     } catch (...) {
85758       {
85759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85760       };
85761     }
85762   }
85763 }
85764
85765
85766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
85767   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85768   unsigned int *arg2 = 0 ;
85769   unsigned int temp2 ;
85770
85771   arg1 = (std::vector< unsigned int > *)jarg1;
85772   temp2 = (unsigned int)jarg2;
85773   arg2 = &temp2;
85774   {
85775     try {
85776       (arg1)->push_back((unsigned int const &)*arg2);
85777     } catch (std::out_of_range& e) {
85778       {
85779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85780       };
85781     } catch (std::exception& e) {
85782       {
85783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85784       };
85785     } catch (...) {
85786       {
85787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85788       };
85789     }
85790   }
85791 }
85792
85793
85794 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
85795   unsigned long jresult ;
85796   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85797   std::vector< unsigned int >::size_type result;
85798
85799   arg1 = (std::vector< unsigned int > *)jarg1;
85800   {
85801     try {
85802       result = ((std::vector< unsigned int > const *)arg1)->size();
85803     } catch (std::out_of_range& e) {
85804       {
85805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85806       };
85807     } catch (std::exception& e) {
85808       {
85809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85810       };
85811     } catch (...) {
85812       {
85813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85814       };
85815     }
85816   }
85817   jresult = (unsigned long)result;
85818   return jresult;
85819 }
85820
85821
85822 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
85823   unsigned long jresult ;
85824   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85825   std::vector< unsigned int >::size_type result;
85826
85827   arg1 = (std::vector< unsigned int > *)jarg1;
85828   {
85829     try {
85830       result = ((std::vector< unsigned int > const *)arg1)->capacity();
85831     } catch (std::out_of_range& e) {
85832       {
85833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85834       };
85835     } catch (std::exception& e) {
85836       {
85837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85838       };
85839     } catch (...) {
85840       {
85841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85842       };
85843     }
85844   }
85845   jresult = (unsigned long)result;
85846   return jresult;
85847 }
85848
85849
85850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
85851   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85852   std::vector< unsigned int >::size_type arg2 ;
85853
85854   arg1 = (std::vector< unsigned int > *)jarg1;
85855   arg2 = (std::vector< unsigned int >::size_type)jarg2;
85856   {
85857     try {
85858       (arg1)->reserve(arg2);
85859     } catch (std::out_of_range& e) {
85860       {
85861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85862       };
85863     } catch (std::exception& e) {
85864       {
85865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85866       };
85867     } catch (...) {
85868       {
85869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85870       };
85871     }
85872   }
85873 }
85874
85875
85876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
85877   void * jresult ;
85878   std::vector< unsigned int > *result = 0 ;
85879
85880   {
85881     try {
85882       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
85883     } catch (std::out_of_range& e) {
85884       {
85885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85886       };
85887     } catch (std::exception& e) {
85888       {
85889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85890       };
85891     } catch (...) {
85892       {
85893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85894       };
85895     }
85896   }
85897   jresult = (void *)result;
85898   return jresult;
85899 }
85900
85901
85902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
85903   void * jresult ;
85904   std::vector< unsigned int > *arg1 = 0 ;
85905   std::vector< unsigned int > *result = 0 ;
85906
85907   arg1 = (std::vector< unsigned int > *)jarg1;
85908   if (!arg1) {
85909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
85910     return 0;
85911   }
85912   {
85913     try {
85914       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
85915     } catch (std::out_of_range& e) {
85916       {
85917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85918       };
85919     } catch (std::exception& e) {
85920       {
85921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85922       };
85923     } catch (...) {
85924       {
85925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85926       };
85927     }
85928   }
85929   jresult = (void *)result;
85930   return jresult;
85931 }
85932
85933
85934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
85935   void * jresult ;
85936   int arg1 ;
85937   std::vector< unsigned int > *result = 0 ;
85938
85939   arg1 = (int)jarg1;
85940   {
85941     try {
85942       try {
85943         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
85944       }
85945       catch(std::out_of_range &_e) {
85946         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85947         return 0;
85948       }
85949
85950     } catch (std::out_of_range& e) {
85951       {
85952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85953       };
85954     } catch (std::exception& e) {
85955       {
85956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85957       };
85958     } catch (...) {
85959       {
85960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85961       };
85962     }
85963   }
85964   jresult = (void *)result;
85965   return jresult;
85966 }
85967
85968
85969 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
85970   unsigned int jresult ;
85971   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85972   int arg2 ;
85973   unsigned int result;
85974
85975   arg1 = (std::vector< unsigned int > *)jarg1;
85976   arg2 = (int)jarg2;
85977   {
85978     try {
85979       try {
85980         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
85981       }
85982       catch(std::out_of_range &_e) {
85983         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85984         return 0;
85985       }
85986
85987     } catch (std::out_of_range& e) {
85988       {
85989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85990       };
85991     } catch (std::exception& e) {
85992       {
85993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85994       };
85995     } catch (...) {
85996       {
85997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85998       };
85999     }
86000   }
86001   jresult = result;
86002   return jresult;
86003 }
86004
86005
86006 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
86007   unsigned int jresult ;
86008   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86009   int arg2 ;
86010   unsigned int *result = 0 ;
86011
86012   arg1 = (std::vector< unsigned int > *)jarg1;
86013   arg2 = (int)jarg2;
86014   {
86015     try {
86016       try {
86017         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
86018       }
86019       catch(std::out_of_range &_e) {
86020         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86021         return 0;
86022       }
86023
86024     } catch (std::out_of_range& e) {
86025       {
86026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86027       };
86028     } catch (std::exception& e) {
86029       {
86030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86031       };
86032     } catch (...) {
86033       {
86034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86035       };
86036     }
86037   }
86038   jresult = *result;
86039   return jresult;
86040 }
86041
86042
86043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
86044   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86045   int arg2 ;
86046   unsigned int *arg3 = 0 ;
86047   unsigned int temp3 ;
86048
86049   arg1 = (std::vector< unsigned int > *)jarg1;
86050   arg2 = (int)jarg2;
86051   temp3 = (unsigned int)jarg3;
86052   arg3 = &temp3;
86053   {
86054     try {
86055       try {
86056         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
86057       }
86058       catch(std::out_of_range &_e) {
86059         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86060         return ;
86061       }
86062
86063     } catch (std::out_of_range& e) {
86064       {
86065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86066       };
86067     } catch (std::exception& e) {
86068       {
86069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86070       };
86071     } catch (...) {
86072       {
86073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86074       };
86075     }
86076   }
86077 }
86078
86079
86080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
86081   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86082   std::vector< unsigned int > *arg2 = 0 ;
86083
86084   arg1 = (std::vector< unsigned int > *)jarg1;
86085   arg2 = (std::vector< unsigned int > *)jarg2;
86086   if (!arg2) {
86087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86088     return ;
86089   }
86090   {
86091     try {
86092       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
86093     } catch (std::out_of_range& e) {
86094       {
86095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86096       };
86097     } catch (std::exception& e) {
86098       {
86099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86100       };
86101     } catch (...) {
86102       {
86103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86104       };
86105     }
86106   }
86107 }
86108
86109
86110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
86111   void * jresult ;
86112   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86113   int arg2 ;
86114   int arg3 ;
86115   std::vector< unsigned int > *result = 0 ;
86116
86117   arg1 = (std::vector< unsigned int > *)jarg1;
86118   arg2 = (int)jarg2;
86119   arg3 = (int)jarg3;
86120   {
86121     try {
86122       try {
86123         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
86124       }
86125       catch(std::out_of_range &_e) {
86126         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86127         return 0;
86128       }
86129       catch(std::invalid_argument &_e) {
86130         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86131         return 0;
86132       }
86133
86134     } catch (std::out_of_range& e) {
86135       {
86136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86137       };
86138     } catch (std::exception& e) {
86139       {
86140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86141       };
86142     } catch (...) {
86143       {
86144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86145       };
86146     }
86147   }
86148   jresult = (void *)result;
86149   return jresult;
86150 }
86151
86152
86153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
86154   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86155   int arg2 ;
86156   unsigned int *arg3 = 0 ;
86157   unsigned int temp3 ;
86158
86159   arg1 = (std::vector< unsigned int > *)jarg1;
86160   arg2 = (int)jarg2;
86161   temp3 = (unsigned int)jarg3;
86162   arg3 = &temp3;
86163   {
86164     try {
86165       try {
86166         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
86167       }
86168       catch(std::out_of_range &_e) {
86169         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86170         return ;
86171       }
86172
86173     } catch (std::out_of_range& e) {
86174       {
86175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86176       };
86177     } catch (std::exception& e) {
86178       {
86179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86180       };
86181     } catch (...) {
86182       {
86183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86184       };
86185     }
86186   }
86187 }
86188
86189
86190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
86191   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86192   int arg2 ;
86193   std::vector< unsigned int > *arg3 = 0 ;
86194
86195   arg1 = (std::vector< unsigned int > *)jarg1;
86196   arg2 = (int)jarg2;
86197   arg3 = (std::vector< unsigned int > *)jarg3;
86198   if (!arg3) {
86199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86200     return ;
86201   }
86202   {
86203     try {
86204       try {
86205         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86206       }
86207       catch(std::out_of_range &_e) {
86208         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86209         return ;
86210       }
86211
86212     } catch (std::out_of_range& e) {
86213       {
86214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86215       };
86216     } catch (std::exception& e) {
86217       {
86218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86219       };
86220     } catch (...) {
86221       {
86222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86223       };
86224     }
86225   }
86226 }
86227
86228
86229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
86230   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86231   int arg2 ;
86232
86233   arg1 = (std::vector< unsigned int > *)jarg1;
86234   arg2 = (int)jarg2;
86235   {
86236     try {
86237       try {
86238         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
86239       }
86240       catch(std::out_of_range &_e) {
86241         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86242         return ;
86243       }
86244
86245     } catch (std::out_of_range& e) {
86246       {
86247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86248       };
86249     } catch (std::exception& e) {
86250       {
86251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86252       };
86253     } catch (...) {
86254       {
86255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86256       };
86257     }
86258   }
86259 }
86260
86261
86262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
86263   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86264   int arg2 ;
86265   int arg3 ;
86266
86267   arg1 = (std::vector< unsigned int > *)jarg1;
86268   arg2 = (int)jarg2;
86269   arg3 = (int)jarg3;
86270   {
86271     try {
86272       try {
86273         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
86274       }
86275       catch(std::out_of_range &_e) {
86276         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86277         return ;
86278       }
86279       catch(std::invalid_argument &_e) {
86280         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86281         return ;
86282       }
86283
86284     } catch (std::out_of_range& e) {
86285       {
86286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86287       };
86288     } catch (std::exception& e) {
86289       {
86290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86291       };
86292     } catch (...) {
86293       {
86294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86295       };
86296     }
86297   }
86298 }
86299
86300
86301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
86302   void * jresult ;
86303   unsigned int *arg1 = 0 ;
86304   int arg2 ;
86305   unsigned int temp1 ;
86306   std::vector< unsigned int > *result = 0 ;
86307
86308   temp1 = (unsigned int)jarg1;
86309   arg1 = &temp1;
86310   arg2 = (int)jarg2;
86311   {
86312     try {
86313       try {
86314         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
86315       }
86316       catch(std::out_of_range &_e) {
86317         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86318         return 0;
86319       }
86320
86321     } catch (std::out_of_range& e) {
86322       {
86323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86324       };
86325     } catch (std::exception& e) {
86326       {
86327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86328       };
86329     } catch (...) {
86330       {
86331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86332       };
86333     }
86334   }
86335   jresult = (void *)result;
86336   return jresult;
86337 }
86338
86339
86340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
86341   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86342
86343   arg1 = (std::vector< unsigned int > *)jarg1;
86344   {
86345     try {
86346       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
86347     } catch (std::out_of_range& e) {
86348       {
86349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86350       };
86351     } catch (std::exception& e) {
86352       {
86353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86354       };
86355     } catch (...) {
86356       {
86357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86358       };
86359     }
86360   }
86361 }
86362
86363
86364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
86365   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86366   int arg2 ;
86367   int arg3 ;
86368
86369   arg1 = (std::vector< unsigned int > *)jarg1;
86370   arg2 = (int)jarg2;
86371   arg3 = (int)jarg3;
86372   {
86373     try {
86374       try {
86375         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
86376       }
86377       catch(std::out_of_range &_e) {
86378         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86379         return ;
86380       }
86381       catch(std::invalid_argument &_e) {
86382         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86383         return ;
86384       }
86385
86386     } catch (std::out_of_range& e) {
86387       {
86388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86389       };
86390     } catch (std::exception& e) {
86391       {
86392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86393       };
86394     } catch (...) {
86395       {
86396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86397       };
86398     }
86399   }
86400 }
86401
86402
86403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
86404   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86405   int arg2 ;
86406   std::vector< unsigned int > *arg3 = 0 ;
86407
86408   arg1 = (std::vector< unsigned int > *)jarg1;
86409   arg2 = (int)jarg2;
86410   arg3 = (std::vector< unsigned int > *)jarg3;
86411   if (!arg3) {
86412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86413     return ;
86414   }
86415   {
86416     try {
86417       try {
86418         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86419       }
86420       catch(std::out_of_range &_e) {
86421         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86422         return ;
86423       }
86424
86425     } catch (std::out_of_range& e) {
86426       {
86427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86428       };
86429     } catch (std::exception& e) {
86430       {
86431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86432       };
86433     } catch (...) {
86434       {
86435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86436       };
86437     }
86438   }
86439 }
86440
86441
86442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
86443   unsigned int jresult ;
86444   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86445   unsigned int *arg2 = 0 ;
86446   unsigned int temp2 ;
86447   bool result;
86448
86449   arg1 = (std::vector< unsigned int > *)jarg1;
86450   temp2 = (unsigned int)jarg2;
86451   arg2 = &temp2;
86452   {
86453     try {
86454       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
86455     } catch (std::out_of_range& e) {
86456       {
86457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86458       };
86459     } catch (std::exception& e) {
86460       {
86461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86462       };
86463     } catch (...) {
86464       {
86465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86466       };
86467     }
86468   }
86469   jresult = result;
86470   return jresult;
86471 }
86472
86473
86474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
86475   int jresult ;
86476   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86477   unsigned int *arg2 = 0 ;
86478   unsigned int temp2 ;
86479   int result;
86480
86481   arg1 = (std::vector< unsigned int > *)jarg1;
86482   temp2 = (unsigned int)jarg2;
86483   arg2 = &temp2;
86484   {
86485     try {
86486       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
86487     } catch (std::out_of_range& e) {
86488       {
86489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86490       };
86491     } catch (std::exception& e) {
86492       {
86493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86494       };
86495     } catch (...) {
86496       {
86497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86498       };
86499     }
86500   }
86501   jresult = result;
86502   return jresult;
86503 }
86504
86505
86506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
86507   int jresult ;
86508   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86509   unsigned int *arg2 = 0 ;
86510   unsigned int temp2 ;
86511   int result;
86512
86513   arg1 = (std::vector< unsigned int > *)jarg1;
86514   temp2 = (unsigned int)jarg2;
86515   arg2 = &temp2;
86516   {
86517     try {
86518       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
86519     } catch (std::out_of_range& e) {
86520       {
86521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86522       };
86523     } catch (std::exception& e) {
86524       {
86525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86526       };
86527     } catch (...) {
86528       {
86529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86530       };
86531     }
86532   }
86533   jresult = result;
86534   return jresult;
86535 }
86536
86537
86538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
86539   unsigned int jresult ;
86540   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86541   unsigned int *arg2 = 0 ;
86542   unsigned int temp2 ;
86543   bool result;
86544
86545   arg1 = (std::vector< unsigned int > *)jarg1;
86546   temp2 = (unsigned int)jarg2;
86547   arg2 = &temp2;
86548   {
86549     try {
86550       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
86551     } catch (std::out_of_range& e) {
86552       {
86553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86554       };
86555     } catch (std::exception& e) {
86556       {
86557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86558       };
86559     } catch (...) {
86560       {
86561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86562       };
86563     }
86564   }
86565   jresult = result;
86566   return jresult;
86567 }
86568
86569
86570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
86571   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86572
86573   arg1 = (std::vector< unsigned int > *)jarg1;
86574   {
86575     try {
86576       delete arg1;
86577     } catch (std::out_of_range& e) {
86578       {
86579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86580       };
86581     } catch (std::exception& e) {
86582       {
86583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86584       };
86585     } catch (...) {
86586       {
86587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86588       };
86589     }
86590   }
86591 }
86592
86593
86594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
86595   void * jresult ;
86596   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86597
86598   {
86599     try {
86600       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
86601     } catch (std::out_of_range& e) {
86602       {
86603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86604       };
86605     } catch (std::exception& e) {
86606       {
86607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86608       };
86609     } catch (...) {
86610       {
86611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86612       };
86613     }
86614   }
86615   jresult = (void *)result;
86616   return jresult;
86617 }
86618
86619
86620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
86621   void * jresult ;
86622   unsigned int arg1 ;
86623   Dali::Actor arg2 ;
86624   Dali::Actor *argp2 ;
86625   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86626
86627   arg1 = (unsigned int)jarg1;
86628   argp2 = (Dali::Actor *)jarg2;
86629   if (!argp2) {
86630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86631     return 0;
86632   }
86633   arg2 = *argp2;
86634   {
86635     try {
86636       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
86637     } catch (std::out_of_range& e) {
86638       {
86639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86640       };
86641     } catch (std::exception& e) {
86642       {
86643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86644       };
86645     } catch (...) {
86646       {
86647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86648       };
86649     }
86650   }
86651   jresult = (void *)result;
86652   return jresult;
86653 }
86654
86655
86656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
86657   void * jresult ;
86658   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
86659   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86660
86661   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86662   if (!arg1) {
86663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86664     return 0;
86665   }
86666   {
86667     try {
86668       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
86669     } catch (std::out_of_range& e) {
86670       {
86671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86672       };
86673     } catch (std::exception& e) {
86674       {
86675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86676       };
86677     } catch (...) {
86678       {
86679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86680       };
86681     }
86682   }
86683   jresult = (void *)result;
86684   return jresult;
86685 }
86686
86687
86688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
86689   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86690   unsigned int arg2 ;
86691
86692   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86693   arg2 = (unsigned int)jarg2;
86694   if (arg1) (arg1)->first = arg2;
86695 }
86696
86697
86698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
86699   unsigned int jresult ;
86700   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86701   unsigned int result;
86702
86703   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86704   result = (unsigned int) ((arg1)->first);
86705   jresult = result;
86706   return jresult;
86707 }
86708
86709
86710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
86711   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86712   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
86713
86714   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86715   arg2 = (Dali::Actor *)jarg2;
86716   if (arg1) (arg1)->second = *arg2;
86717 }
86718
86719
86720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
86721   void * jresult ;
86722   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86723   Dali::Actor *result = 0 ;
86724
86725   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86726   result = (Dali::Actor *)& ((arg1)->second);
86727   jresult = (void *)result;
86728   return jresult;
86729 }
86730
86731
86732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
86733   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86734
86735   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86736   {
86737     try {
86738       delete arg1;
86739     } catch (std::out_of_range& e) {
86740       {
86741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86742       };
86743     } catch (std::exception& e) {
86744       {
86745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86746       };
86747     } catch (...) {
86748       {
86749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86750       };
86751     }
86752   }
86753 }
86754
86755
86756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
86757   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86758
86759   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86760   {
86761     try {
86762       (arg1)->clear();
86763     } catch (std::out_of_range& e) {
86764       {
86765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86766       };
86767     } catch (std::exception& e) {
86768       {
86769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86770       };
86771     } catch (...) {
86772       {
86773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86774       };
86775     }
86776   }
86777 }
86778
86779
86780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
86781   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86782   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
86783
86784   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86785   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
86786   if (!arg2) {
86787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86788     return ;
86789   }
86790   {
86791     try {
86792       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
86793     } catch (std::out_of_range& e) {
86794       {
86795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86796       };
86797     } catch (std::exception& e) {
86798       {
86799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86800       };
86801     } catch (...) {
86802       {
86803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86804       };
86805     }
86806   }
86807 }
86808
86809
86810 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
86811   unsigned long jresult ;
86812   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86813   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
86814
86815   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86816   {
86817     try {
86818       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
86819     } catch (std::out_of_range& e) {
86820       {
86821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86822       };
86823     } catch (std::exception& e) {
86824       {
86825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86826       };
86827     } catch (...) {
86828       {
86829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86830       };
86831     }
86832   }
86833   jresult = (unsigned long)result;
86834   return jresult;
86835 }
86836
86837
86838 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
86839   unsigned long jresult ;
86840   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86841   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
86842
86843   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86844   {
86845     try {
86846       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
86847     } catch (std::out_of_range& e) {
86848       {
86849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86850       };
86851     } catch (std::exception& e) {
86852       {
86853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86854       };
86855     } catch (...) {
86856       {
86857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86858       };
86859     }
86860   }
86861   jresult = (unsigned long)result;
86862   return jresult;
86863 }
86864
86865
86866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
86867   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86868   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
86869
86870   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86871   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
86872   {
86873     try {
86874       (arg1)->reserve(arg2);
86875     } catch (std::out_of_range& e) {
86876       {
86877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86878       };
86879     } catch (std::exception& e) {
86880       {
86881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86882       };
86883     } catch (...) {
86884       {
86885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86886       };
86887     }
86888   }
86889 }
86890
86891
86892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
86893   void * jresult ;
86894   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86895
86896   {
86897     try {
86898       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
86899     } catch (std::out_of_range& e) {
86900       {
86901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86902       };
86903     } catch (std::exception& e) {
86904       {
86905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86906       };
86907     } catch (...) {
86908       {
86909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86910       };
86911     }
86912   }
86913   jresult = (void *)result;
86914   return jresult;
86915 }
86916
86917
86918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
86919   void * jresult ;
86920   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
86921   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86922
86923   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86924   if (!arg1) {
86925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
86926     return 0;
86927   }
86928   {
86929     try {
86930       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);
86931     } catch (std::out_of_range& e) {
86932       {
86933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86934       };
86935     } catch (std::exception& e) {
86936       {
86937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86938       };
86939     } catch (...) {
86940       {
86941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86942       };
86943     }
86944   }
86945   jresult = (void *)result;
86946   return jresult;
86947 }
86948
86949
86950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
86951   void * jresult ;
86952   int arg1 ;
86953   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86954
86955   arg1 = (int)jarg1;
86956   {
86957     try {
86958       try {
86959         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);
86960       }
86961       catch(std::out_of_range &_e) {
86962         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86963         return 0;
86964       }
86965
86966     } catch (std::out_of_range& e) {
86967       {
86968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86969       };
86970     } catch (std::exception& e) {
86971       {
86972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86973       };
86974     } catch (...) {
86975       {
86976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86977       };
86978     }
86979   }
86980   jresult = (void *)result;
86981   return jresult;
86982 }
86983
86984
86985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
86986   void * jresult ;
86987   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86988   int arg2 ;
86989   std::pair< unsigned int,Dali::Actor > result;
86990
86991   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86992   arg2 = (int)jarg2;
86993   {
86994     try {
86995       try {
86996         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
86997       }
86998       catch(std::out_of_range &_e) {
86999         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87000         return 0;
87001       }
87002
87003     } catch (std::out_of_range& e) {
87004       {
87005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87006       };
87007     } catch (std::exception& e) {
87008       {
87009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87010       };
87011     } catch (...) {
87012       {
87013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87014       };
87015     }
87016   }
87017   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
87018   return jresult;
87019 }
87020
87021
87022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
87023   void * jresult ;
87024   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87025   int arg2 ;
87026   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87027
87028   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87029   arg2 = (int)jarg2;
87030   {
87031     try {
87032       try {
87033         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
87034       }
87035       catch(std::out_of_range &_e) {
87036         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87037         return 0;
87038       }
87039
87040     } catch (std::out_of_range& e) {
87041       {
87042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87043       };
87044     } catch (std::exception& e) {
87045       {
87046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87047       };
87048     } catch (...) {
87049       {
87050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87051       };
87052     }
87053   }
87054   jresult = (void *)result;
87055   return jresult;
87056 }
87057
87058
87059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
87060   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87061   int arg2 ;
87062   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
87063
87064   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87065   arg2 = (int)jarg2;
87066   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
87067   if (!arg3) {
87068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87069     return ;
87070   }
87071   {
87072     try {
87073       try {
87074         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);
87075       }
87076       catch(std::out_of_range &_e) {
87077         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87078         return ;
87079       }
87080
87081     } catch (std::out_of_range& e) {
87082       {
87083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87084       };
87085     } catch (std::exception& e) {
87086       {
87087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87088       };
87089     } catch (...) {
87090       {
87091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87092       };
87093     }
87094   }
87095 }
87096
87097
87098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
87099   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87100   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
87101
87102   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87103   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
87104   if (!arg2) {
87105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87106     return ;
87107   }
87108   {
87109     try {
87110       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);
87111     } catch (std::out_of_range& e) {
87112       {
87113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87114       };
87115     } catch (std::exception& e) {
87116       {
87117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87118       };
87119     } catch (...) {
87120       {
87121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87122       };
87123     }
87124   }
87125 }
87126
87127
87128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87129   void * jresult ;
87130   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87131   int arg2 ;
87132   int arg3 ;
87133   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87134
87135   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87136   arg2 = (int)jarg2;
87137   arg3 = (int)jarg3;
87138   {
87139     try {
87140       try {
87141         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);
87142       }
87143       catch(std::out_of_range &_e) {
87144         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87145         return 0;
87146       }
87147       catch(std::invalid_argument &_e) {
87148         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87149         return 0;
87150       }
87151
87152     } catch (std::out_of_range& e) {
87153       {
87154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87155       };
87156     } catch (std::exception& e) {
87157       {
87158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87159       };
87160     } catch (...) {
87161       {
87162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87163       };
87164     }
87165   }
87166   jresult = (void *)result;
87167   return jresult;
87168 }
87169
87170
87171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
87172   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87173   int arg2 ;
87174   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
87175
87176   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87177   arg2 = (int)jarg2;
87178   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
87179   if (!arg3) {
87180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87181     return ;
87182   }
87183   {
87184     try {
87185       try {
87186         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);
87187       }
87188       catch(std::out_of_range &_e) {
87189         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87190         return ;
87191       }
87192
87193     } catch (std::out_of_range& e) {
87194       {
87195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87196       };
87197     } catch (std::exception& e) {
87198       {
87199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87200       };
87201     } catch (...) {
87202       {
87203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87204       };
87205     }
87206   }
87207 }
87208
87209
87210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87211   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87212   int arg2 ;
87213   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87214
87215   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87216   arg2 = (int)jarg2;
87217   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87218   if (!arg3) {
87219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87220     return ;
87221   }
87222   {
87223     try {
87224       try {
87225         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);
87226       }
87227       catch(std::out_of_range &_e) {
87228         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87229         return ;
87230       }
87231
87232     } catch (std::out_of_range& e) {
87233       {
87234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87235       };
87236     } catch (std::exception& e) {
87237       {
87238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87239       };
87240     } catch (...) {
87241       {
87242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87243       };
87244     }
87245   }
87246 }
87247
87248
87249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
87250   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87251   int arg2 ;
87252
87253   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87254   arg2 = (int)jarg2;
87255   {
87256     try {
87257       try {
87258         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
87259       }
87260       catch(std::out_of_range &_e) {
87261         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87262         return ;
87263       }
87264
87265     } catch (std::out_of_range& e) {
87266       {
87267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87268       };
87269     } catch (std::exception& e) {
87270       {
87271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87272       };
87273     } catch (...) {
87274       {
87275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87276       };
87277     }
87278   }
87279 }
87280
87281
87282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87283   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87284   int arg2 ;
87285   int arg3 ;
87286
87287   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87288   arg2 = (int)jarg2;
87289   arg3 = (int)jarg3;
87290   {
87291     try {
87292       try {
87293         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
87294       }
87295       catch(std::out_of_range &_e) {
87296         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87297         return ;
87298       }
87299       catch(std::invalid_argument &_e) {
87300         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87301         return ;
87302       }
87303
87304     } catch (std::out_of_range& e) {
87305       {
87306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87307       };
87308     } catch (std::exception& e) {
87309       {
87310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87311       };
87312     } catch (...) {
87313       {
87314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87315       };
87316     }
87317   }
87318 }
87319
87320
87321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
87322   void * jresult ;
87323   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
87324   int arg2 ;
87325   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87326
87327   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87328   if (!arg1) {
87329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87330     return 0;
87331   }
87332   arg2 = (int)jarg2;
87333   {
87334     try {
87335       try {
87336         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);
87337       }
87338       catch(std::out_of_range &_e) {
87339         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87340         return 0;
87341       }
87342
87343     } catch (std::out_of_range& e) {
87344       {
87345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87346       };
87347     } catch (std::exception& e) {
87348       {
87349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87350       };
87351     } catch (...) {
87352       {
87353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87354       };
87355     }
87356   }
87357   jresult = (void *)result;
87358   return jresult;
87359 }
87360
87361
87362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
87363   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87364
87365   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87366   {
87367     try {
87368       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
87369     } catch (std::out_of_range& e) {
87370       {
87371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87372       };
87373     } catch (std::exception& e) {
87374       {
87375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87376       };
87377     } catch (...) {
87378       {
87379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87380       };
87381     }
87382   }
87383 }
87384
87385
87386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87387   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87388   int arg2 ;
87389   int arg3 ;
87390
87391   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87392   arg2 = (int)jarg2;
87393   arg3 = (int)jarg3;
87394   {
87395     try {
87396       try {
87397         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87398       }
87399       catch(std::out_of_range &_e) {
87400         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87401         return ;
87402       }
87403       catch(std::invalid_argument &_e) {
87404         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87405         return ;
87406       }
87407
87408     } catch (std::out_of_range& e) {
87409       {
87410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87411       };
87412     } catch (std::exception& e) {
87413       {
87414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87415       };
87416     } catch (...) {
87417       {
87418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87419       };
87420     }
87421   }
87422 }
87423
87424
87425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87426   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87427   int arg2 ;
87428   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87429
87430   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87431   arg2 = (int)jarg2;
87432   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87433   if (!arg3) {
87434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87435     return ;
87436   }
87437   {
87438     try {
87439       try {
87440         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);
87441       }
87442       catch(std::out_of_range &_e) {
87443         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87444         return ;
87445       }
87446
87447     } catch (std::out_of_range& e) {
87448       {
87449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87450       };
87451     } catch (std::exception& e) {
87452       {
87453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87454       };
87455     } catch (...) {
87456       {
87457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87458       };
87459     }
87460   }
87461 }
87462
87463
87464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
87465   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87466
87467   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87468   {
87469     try {
87470       delete arg1;
87471     } catch (std::out_of_range& e) {
87472       {
87473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87474       };
87475     } catch (std::exception& e) {
87476       {
87477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87478       };
87479     } catch (...) {
87480       {
87481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87482       };
87483     }
87484   }
87485 }
87486
87487
87488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
87489   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87490
87491   arg1 = (std::vector< Dali::Actor > *)jarg1;
87492   {
87493     try {
87494       (arg1)->clear();
87495     } catch (std::out_of_range& e) {
87496       {
87497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87498       };
87499     } catch (std::exception& e) {
87500       {
87501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87502       };
87503     } catch (...) {
87504       {
87505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87506       };
87507     }
87508   }
87509 }
87510
87511
87512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
87513   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87514   Dali::Actor *arg2 = 0 ;
87515
87516   arg1 = (std::vector< Dali::Actor > *)jarg1;
87517   arg2 = (Dali::Actor *)jarg2;
87518   if (!arg2) {
87519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87520     return ;
87521   }
87522   {
87523     try {
87524       (arg1)->push_back((Dali::Actor const &)*arg2);
87525     } catch (std::out_of_range& e) {
87526       {
87527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87528       };
87529     } catch (std::exception& e) {
87530       {
87531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87532       };
87533     } catch (...) {
87534       {
87535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87536       };
87537     }
87538   }
87539 }
87540
87541
87542 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
87543   unsigned long jresult ;
87544   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87545   std::vector< Dali::Actor >::size_type result;
87546
87547   arg1 = (std::vector< Dali::Actor > *)jarg1;
87548   {
87549     try {
87550       result = ((std::vector< Dali::Actor > const *)arg1)->size();
87551     } catch (std::out_of_range& e) {
87552       {
87553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87554       };
87555     } catch (std::exception& e) {
87556       {
87557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87558       };
87559     } catch (...) {
87560       {
87561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87562       };
87563     }
87564   }
87565   jresult = (unsigned long)result;
87566   return jresult;
87567 }
87568
87569
87570 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
87571   unsigned long jresult ;
87572   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87573   std::vector< Dali::Actor >::size_type result;
87574
87575   arg1 = (std::vector< Dali::Actor > *)jarg1;
87576   {
87577     try {
87578       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
87579     } catch (std::out_of_range& e) {
87580       {
87581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87582       };
87583     } catch (std::exception& e) {
87584       {
87585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87586       };
87587     } catch (...) {
87588       {
87589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87590       };
87591     }
87592   }
87593   jresult = (unsigned long)result;
87594   return jresult;
87595 }
87596
87597
87598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
87599   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87600   std::vector< Dali::Actor >::size_type arg2 ;
87601
87602   arg1 = (std::vector< Dali::Actor > *)jarg1;
87603   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
87604   {
87605     try {
87606       (arg1)->reserve(arg2);
87607     } catch (std::out_of_range& e) {
87608       {
87609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87610       };
87611     } catch (std::exception& e) {
87612       {
87613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87614       };
87615     } catch (...) {
87616       {
87617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87618       };
87619     }
87620   }
87621 }
87622
87623
87624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
87625   void * jresult ;
87626   std::vector< Dali::Actor > *result = 0 ;
87627
87628   {
87629     try {
87630       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
87631     } catch (std::out_of_range& e) {
87632       {
87633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87634       };
87635     } catch (std::exception& e) {
87636       {
87637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87638       };
87639     } catch (...) {
87640       {
87641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87642       };
87643     }
87644   }
87645   jresult = (void *)result;
87646   return jresult;
87647 }
87648
87649
87650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
87651   void * jresult ;
87652   std::vector< Dali::Actor > *arg1 = 0 ;
87653   std::vector< Dali::Actor > *result = 0 ;
87654
87655   arg1 = (std::vector< Dali::Actor > *)jarg1;
87656   if (!arg1) {
87657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87658     return 0;
87659   }
87660   {
87661     try {
87662       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
87663     } catch (std::out_of_range& e) {
87664       {
87665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87666       };
87667     } catch (std::exception& e) {
87668       {
87669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87670       };
87671     } catch (...) {
87672       {
87673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87674       };
87675     }
87676   }
87677   jresult = (void *)result;
87678   return jresult;
87679 }
87680
87681
87682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
87683   void * jresult ;
87684   int arg1 ;
87685   std::vector< Dali::Actor > *result = 0 ;
87686
87687   arg1 = (int)jarg1;
87688   {
87689     try {
87690       try {
87691         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
87692       }
87693       catch(std::out_of_range &_e) {
87694         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87695         return 0;
87696       }
87697
87698     } catch (std::out_of_range& e) {
87699       {
87700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87701       };
87702     } catch (std::exception& e) {
87703       {
87704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87705       };
87706     } catch (...) {
87707       {
87708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87709       };
87710     }
87711   }
87712   jresult = (void *)result;
87713   return jresult;
87714 }
87715
87716
87717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
87718   void * jresult ;
87719   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87720   int arg2 ;
87721   Dali::Actor result;
87722
87723   arg1 = (std::vector< Dali::Actor > *)jarg1;
87724   arg2 = (int)jarg2;
87725   {
87726     try {
87727       try {
87728         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
87729       }
87730       catch(std::out_of_range &_e) {
87731         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87732         return 0;
87733       }
87734
87735     } catch (std::out_of_range& e) {
87736       {
87737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87738       };
87739     } catch (std::exception& e) {
87740       {
87741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87742       };
87743     } catch (...) {
87744       {
87745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87746       };
87747     }
87748   }
87749   jresult = new Dali::Actor((const Dali::Actor &)result);
87750   return jresult;
87751 }
87752
87753
87754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
87755   void * jresult ;
87756   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87757   int arg2 ;
87758   Dali::Actor *result = 0 ;
87759
87760   arg1 = (std::vector< Dali::Actor > *)jarg1;
87761   arg2 = (int)jarg2;
87762   {
87763     try {
87764       try {
87765         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
87766       }
87767       catch(std::out_of_range &_e) {
87768         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87769         return 0;
87770       }
87771
87772     } catch (std::out_of_range& e) {
87773       {
87774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87775       };
87776     } catch (std::exception& e) {
87777       {
87778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87779       };
87780     } catch (...) {
87781       {
87782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87783       };
87784     }
87785   }
87786   jresult = (void *)result;
87787   return jresult;
87788 }
87789
87790
87791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
87792   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87793   int arg2 ;
87794   Dali::Actor *arg3 = 0 ;
87795
87796   arg1 = (std::vector< Dali::Actor > *)jarg1;
87797   arg2 = (int)jarg2;
87798   arg3 = (Dali::Actor *)jarg3;
87799   if (!arg3) {
87800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87801     return ;
87802   }
87803   {
87804     try {
87805       try {
87806         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
87807       }
87808       catch(std::out_of_range &_e) {
87809         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87810         return ;
87811       }
87812
87813     } catch (std::out_of_range& e) {
87814       {
87815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87816       };
87817     } catch (std::exception& e) {
87818       {
87819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87820       };
87821     } catch (...) {
87822       {
87823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87824       };
87825     }
87826   }
87827 }
87828
87829
87830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
87831   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87832   std::vector< Dali::Actor > *arg2 = 0 ;
87833
87834   arg1 = (std::vector< Dali::Actor > *)jarg1;
87835   arg2 = (std::vector< Dali::Actor > *)jarg2;
87836   if (!arg2) {
87837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87838     return ;
87839   }
87840   {
87841     try {
87842       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
87843     } catch (std::out_of_range& e) {
87844       {
87845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87846       };
87847     } catch (std::exception& e) {
87848       {
87849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87850       };
87851     } catch (...) {
87852       {
87853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87854       };
87855     }
87856   }
87857 }
87858
87859
87860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87861   void * jresult ;
87862   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87863   int arg2 ;
87864   int arg3 ;
87865   std::vector< Dali::Actor > *result = 0 ;
87866
87867   arg1 = (std::vector< Dali::Actor > *)jarg1;
87868   arg2 = (int)jarg2;
87869   arg3 = (int)jarg3;
87870   {
87871     try {
87872       try {
87873         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
87874       }
87875       catch(std::out_of_range &_e) {
87876         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87877         return 0;
87878       }
87879       catch(std::invalid_argument &_e) {
87880         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87881         return 0;
87882       }
87883
87884     } catch (std::out_of_range& e) {
87885       {
87886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87887       };
87888     } catch (std::exception& e) {
87889       {
87890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87891       };
87892     } catch (...) {
87893       {
87894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87895       };
87896     }
87897   }
87898   jresult = (void *)result;
87899   return jresult;
87900 }
87901
87902
87903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
87904   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87905   int arg2 ;
87906   Dali::Actor *arg3 = 0 ;
87907
87908   arg1 = (std::vector< Dali::Actor > *)jarg1;
87909   arg2 = (int)jarg2;
87910   arg3 = (Dali::Actor *)jarg3;
87911   if (!arg3) {
87912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87913     return ;
87914   }
87915   {
87916     try {
87917       try {
87918         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
87919       }
87920       catch(std::out_of_range &_e) {
87921         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87922         return ;
87923       }
87924
87925     } catch (std::out_of_range& e) {
87926       {
87927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87928       };
87929     } catch (std::exception& e) {
87930       {
87931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87932       };
87933     } catch (...) {
87934       {
87935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87936       };
87937     }
87938   }
87939 }
87940
87941
87942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87943   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87944   int arg2 ;
87945   std::vector< Dali::Actor > *arg3 = 0 ;
87946
87947   arg1 = (std::vector< Dali::Actor > *)jarg1;
87948   arg2 = (int)jarg2;
87949   arg3 = (std::vector< Dali::Actor > *)jarg3;
87950   if (!arg3) {
87951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87952     return ;
87953   }
87954   {
87955     try {
87956       try {
87957         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
87958       }
87959       catch(std::out_of_range &_e) {
87960         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87961         return ;
87962       }
87963
87964     } catch (std::out_of_range& e) {
87965       {
87966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87967       };
87968     } catch (std::exception& e) {
87969       {
87970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87971       };
87972     } catch (...) {
87973       {
87974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87975       };
87976     }
87977   }
87978 }
87979
87980
87981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
87982   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87983   int arg2 ;
87984
87985   arg1 = (std::vector< Dali::Actor > *)jarg1;
87986   arg2 = (int)jarg2;
87987   {
87988     try {
87989       try {
87990         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
87991       }
87992       catch(std::out_of_range &_e) {
87993         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87994         return ;
87995       }
87996
87997     } catch (std::out_of_range& e) {
87998       {
87999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88000       };
88001     } catch (std::exception& e) {
88002       {
88003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88004       };
88005     } catch (...) {
88006       {
88007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88008       };
88009     }
88010   }
88011 }
88012
88013
88014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88015   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88016   int arg2 ;
88017   int arg3 ;
88018
88019   arg1 = (std::vector< Dali::Actor > *)jarg1;
88020   arg2 = (int)jarg2;
88021   arg3 = (int)jarg3;
88022   {
88023     try {
88024       try {
88025         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
88026       }
88027       catch(std::out_of_range &_e) {
88028         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88029         return ;
88030       }
88031       catch(std::invalid_argument &_e) {
88032         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88033         return ;
88034       }
88035
88036     } catch (std::out_of_range& e) {
88037       {
88038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88039       };
88040     } catch (std::exception& e) {
88041       {
88042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88043       };
88044     } catch (...) {
88045       {
88046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88047       };
88048     }
88049   }
88050 }
88051
88052
88053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
88054   void * jresult ;
88055   Dali::Actor *arg1 = 0 ;
88056   int arg2 ;
88057   std::vector< Dali::Actor > *result = 0 ;
88058
88059   arg1 = (Dali::Actor *)jarg1;
88060   if (!arg1) {
88061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88062     return 0;
88063   }
88064   arg2 = (int)jarg2;
88065   {
88066     try {
88067       try {
88068         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
88069       }
88070       catch(std::out_of_range &_e) {
88071         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88072         return 0;
88073       }
88074
88075     } catch (std::out_of_range& e) {
88076       {
88077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88078       };
88079     } catch (std::exception& e) {
88080       {
88081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88082       };
88083     } catch (...) {
88084       {
88085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88086       };
88087     }
88088   }
88089   jresult = (void *)result;
88090   return jresult;
88091 }
88092
88093
88094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
88095   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88096
88097   arg1 = (std::vector< Dali::Actor > *)jarg1;
88098   {
88099     try {
88100       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
88101     } catch (std::out_of_range& e) {
88102       {
88103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88104       };
88105     } catch (std::exception& e) {
88106       {
88107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88108       };
88109     } catch (...) {
88110       {
88111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88112       };
88113     }
88114   }
88115 }
88116
88117
88118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88119   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88120   int arg2 ;
88121   int arg3 ;
88122
88123   arg1 = (std::vector< Dali::Actor > *)jarg1;
88124   arg2 = (int)jarg2;
88125   arg3 = (int)jarg3;
88126   {
88127     try {
88128       try {
88129         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88130       }
88131       catch(std::out_of_range &_e) {
88132         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88133         return ;
88134       }
88135       catch(std::invalid_argument &_e) {
88136         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88137         return ;
88138       }
88139
88140     } catch (std::out_of_range& e) {
88141       {
88142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88143       };
88144     } catch (std::exception& e) {
88145       {
88146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88147       };
88148     } catch (...) {
88149       {
88150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88151       };
88152     }
88153   }
88154 }
88155
88156
88157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88158   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88159   int arg2 ;
88160   std::vector< Dali::Actor > *arg3 = 0 ;
88161
88162   arg1 = (std::vector< Dali::Actor > *)jarg1;
88163   arg2 = (int)jarg2;
88164   arg3 = (std::vector< Dali::Actor > *)jarg3;
88165   if (!arg3) {
88166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88167     return ;
88168   }
88169   {
88170     try {
88171       try {
88172         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
88173       }
88174       catch(std::out_of_range &_e) {
88175         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88176         return ;
88177       }
88178
88179     } catch (std::out_of_range& e) {
88180       {
88181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88182       };
88183     } catch (std::exception& e) {
88184       {
88185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88186       };
88187     } catch (...) {
88188       {
88189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88190       };
88191     }
88192   }
88193 }
88194
88195
88196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
88197   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88198
88199   arg1 = (std::vector< Dali::Actor > *)jarg1;
88200   {
88201     try {
88202       delete arg1;
88203     } catch (std::out_of_range& e) {
88204       {
88205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88206       };
88207     } catch (std::exception& e) {
88208       {
88209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88210       };
88211     } catch (...) {
88212       {
88213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88214       };
88215     }
88216   }
88217 }
88218
88219
88220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
88221   unsigned int jresult ;
88222   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88223   bool result;
88224
88225   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88226   {
88227     try {
88228       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88229     } catch (std::out_of_range& e) {
88230       {
88231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88232       };
88233     } catch (std::exception& e) {
88234       {
88235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88236       };
88237     } catch (...) {
88238       {
88239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88240       };
88241     }
88242   }
88243   jresult = result;
88244   return jresult;
88245 }
88246
88247
88248 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
88249   unsigned long jresult ;
88250   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88251   std::size_t result;
88252
88253   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88254   {
88255     try {
88256       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88257     } catch (std::out_of_range& e) {
88258       {
88259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88260       };
88261     } catch (std::exception& e) {
88262       {
88263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88264       };
88265     } catch (...) {
88266       {
88267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88268       };
88269     }
88270   }
88271   jresult = (unsigned long)result;
88272   return jresult;
88273 }
88274
88275
88276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
88277   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88278   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88279
88280   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88281   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88282   {
88283     try {
88284       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
88285     } catch (std::out_of_range& e) {
88286       {
88287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88288       };
88289     } catch (std::exception& e) {
88290       {
88291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88292       };
88293     } catch (...) {
88294       {
88295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88296       };
88297     }
88298   }
88299 }
88300
88301
88302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
88303   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88304   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88305
88306   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88307   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88308   {
88309     try {
88310       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
88311     } catch (std::out_of_range& e) {
88312       {
88313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88314       };
88315     } catch (std::exception& e) {
88316       {
88317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88318       };
88319     } catch (...) {
88320       {
88321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88322       };
88323     }
88324   }
88325 }
88326
88327
88328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
88329   unsigned int jresult ;
88330   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88331   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
88332   bool result;
88333
88334   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88335   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
88336   if (!arg2) {
88337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
88338     return 0;
88339   }
88340   {
88341     try {
88342       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
88343     } catch (std::out_of_range& e) {
88344       {
88345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88346       };
88347     } catch (std::exception& e) {
88348       {
88349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88350       };
88351     } catch (...) {
88352       {
88353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88354       };
88355     }
88356   }
88357   jresult = result;
88358   return jresult;
88359 }
88360
88361
88362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
88363   void * jresult ;
88364   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
88365
88366   {
88367     try {
88368       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
88369     } catch (std::out_of_range& e) {
88370       {
88371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88372       };
88373     } catch (std::exception& e) {
88374       {
88375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88376       };
88377     } catch (...) {
88378       {
88379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88380       };
88381     }
88382   }
88383   jresult = (void *)result;
88384   return jresult;
88385 }
88386
88387
88388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
88389   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88390
88391   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88392   {
88393     try {
88394       delete arg1;
88395     } catch (std::out_of_range& e) {
88396       {
88397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88398       };
88399     } catch (std::exception& e) {
88400       {
88401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88402       };
88403     } catch (...) {
88404       {
88405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88406       };
88407     }
88408   }
88409 }
88410
88411
88412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
88413   unsigned int jresult ;
88414   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88415   bool result;
88416
88417   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88418   {
88419     try {
88420       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);
88421     } catch (std::out_of_range& e) {
88422       {
88423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88424       };
88425     } catch (std::exception& e) {
88426       {
88427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88428       };
88429     } catch (...) {
88430       {
88431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88432       };
88433     }
88434   }
88435   jresult = result;
88436   return jresult;
88437 }
88438
88439
88440 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
88441   unsigned long jresult ;
88442   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88443   std::size_t result;
88444
88445   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88446   {
88447     try {
88448       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);
88449     } catch (std::out_of_range& e) {
88450       {
88451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88452       };
88453     } catch (std::exception& e) {
88454       {
88455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88456       };
88457     } catch (...) {
88458       {
88459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88460       };
88461     }
88462   }
88463   jresult = (unsigned long)result;
88464   return jresult;
88465 }
88466
88467
88468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
88469   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88470   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88471
88472   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88473   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88474   {
88475     try {
88476       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
88477     } catch (std::out_of_range& e) {
88478       {
88479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88480       };
88481     } catch (std::exception& e) {
88482       {
88483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88484       };
88485     } catch (...) {
88486       {
88487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88488       };
88489     }
88490   }
88491 }
88492
88493
88494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
88495   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88496   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88497
88498   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88499   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88500   {
88501     try {
88502       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
88503     } catch (std::out_of_range& e) {
88504       {
88505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88506       };
88507     } catch (std::exception& e) {
88508       {
88509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88510       };
88511     } catch (...) {
88512       {
88513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88514       };
88515     }
88516   }
88517 }
88518
88519
88520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
88521   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88522   Dali::Actor arg2 ;
88523   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
88524   Dali::Actor *argp2 ;
88525
88526   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88527   argp2 = (Dali::Actor *)jarg2;
88528   if (!argp2) {
88529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88530     return ;
88531   }
88532   arg2 = *argp2;
88533   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
88534   {
88535     try {
88536       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
88537     } catch (std::out_of_range& e) {
88538       {
88539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88540       };
88541     } catch (std::exception& e) {
88542       {
88543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88544       };
88545     } catch (...) {
88546       {
88547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88548       };
88549     }
88550   }
88551 }
88552
88553
88554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
88555   void * jresult ;
88556   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
88557
88558   {
88559     try {
88560       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
88561     } catch (std::out_of_range& e) {
88562       {
88563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88564       };
88565     } catch (std::exception& e) {
88566       {
88567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88568       };
88569     } catch (...) {
88570       {
88571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88572       };
88573     }
88574   }
88575   jresult = (void *)result;
88576   return jresult;
88577 }
88578
88579
88580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
88581   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88582
88583   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88584   {
88585     try {
88586       delete arg1;
88587     } catch (std::out_of_range& e) {
88588       {
88589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88590       };
88591     } catch (std::exception& e) {
88592       {
88593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88594       };
88595     } catch (...) {
88596       {
88597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88598       };
88599     }
88600   }
88601 }
88602
88603
88604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
88605   unsigned int jresult ;
88606   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88607   bool result;
88608
88609   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88610   {
88611     try {
88612       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
88613     } catch (std::out_of_range& e) {
88614       {
88615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88616       };
88617     } catch (std::exception& e) {
88618       {
88619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88620       };
88621     } catch (...) {
88622       {
88623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88624       };
88625     }
88626   }
88627   jresult = result;
88628   return jresult;
88629 }
88630
88631
88632 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
88633   unsigned long jresult ;
88634   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88635   std::size_t result;
88636
88637   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88638   {
88639     try {
88640       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
88641     } catch (std::out_of_range& e) {
88642       {
88643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88644       };
88645     } catch (std::exception& e) {
88646       {
88647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88648       };
88649     } catch (...) {
88650       {
88651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88652       };
88653     }
88654   }
88655   jresult = (unsigned long)result;
88656   return jresult;
88657 }
88658
88659
88660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
88661   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88662   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88663
88664   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88665   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88666   {
88667     try {
88668       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
88669     } catch (std::out_of_range& e) {
88670       {
88671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88672       };
88673     } catch (std::exception& e) {
88674       {
88675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88676       };
88677     } catch (...) {
88678       {
88679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88680       };
88681     }
88682   }
88683 }
88684
88685
88686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88687   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88688   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88689
88690   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88691   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88692   {
88693     try {
88694       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
88695     } catch (std::out_of_range& e) {
88696       {
88697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88698       };
88699     } catch (std::exception& e) {
88700       {
88701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88702       };
88703     } catch (...) {
88704       {
88705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88706       };
88707     }
88708   }
88709 }
88710
88711
88712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
88713   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88714   Dali::Actor arg2 ;
88715   Dali::Actor arg3 ;
88716   Dali::Actor *argp2 ;
88717   Dali::Actor *argp3 ;
88718
88719   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88720   argp2 = (Dali::Actor *)jarg2;
88721   if (!argp2) {
88722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88723     return ;
88724   }
88725   arg2 = *argp2;
88726   argp3 = (Dali::Actor *)jarg3;
88727   if (!argp3) {
88728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88729     return ;
88730   }
88731   arg3 = *argp3;
88732   {
88733     try {
88734       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
88735     } catch (std::out_of_range& e) {
88736       {
88737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88738       };
88739     } catch (std::exception& e) {
88740       {
88741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88742       };
88743     } catch (...) {
88744       {
88745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88746       };
88747     }
88748   }
88749 }
88750
88751
88752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
88753   void * jresult ;
88754   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
88755
88756   {
88757     try {
88758       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
88759     } catch (std::out_of_range& e) {
88760       {
88761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88762       };
88763     } catch (std::exception& e) {
88764       {
88765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88766       };
88767     } catch (...) {
88768       {
88769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88770       };
88771     }
88772   }
88773   jresult = (void *)result;
88774   return jresult;
88775 }
88776
88777
88778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
88779   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88780
88781   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88782   {
88783     try {
88784       delete arg1;
88785     } catch (std::out_of_range& e) {
88786       {
88787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88788       };
88789     } catch (std::exception& e) {
88790       {
88791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88792       };
88793     } catch (...) {
88794       {
88795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88796       };
88797     }
88798   }
88799 }
88800
88801
88802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
88803   unsigned int jresult ;
88804   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88805   bool result;
88806
88807   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88808   {
88809     try {
88810       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
88811     } catch (std::out_of_range& e) {
88812       {
88813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88814       };
88815     } catch (std::exception& e) {
88816       {
88817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88818       };
88819     } catch (...) {
88820       {
88821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88822       };
88823     }
88824   }
88825   jresult = result;
88826   return jresult;
88827 }
88828
88829
88830 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
88831   unsigned long jresult ;
88832   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88833   std::size_t result;
88834
88835   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88836   {
88837     try {
88838       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
88839     } catch (std::out_of_range& e) {
88840       {
88841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88842       };
88843     } catch (std::exception& e) {
88844       {
88845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88846       };
88847     } catch (...) {
88848       {
88849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88850       };
88851     }
88852   }
88853   jresult = (unsigned long)result;
88854   return jresult;
88855 }
88856
88857
88858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
88859   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88860   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
88861
88862   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88863   arg2 = (void (*)(Dali::Actor,bool))jarg2;
88864   {
88865     try {
88866       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
88867     } catch (std::out_of_range& e) {
88868       {
88869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88870       };
88871     } catch (std::exception& e) {
88872       {
88873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88874       };
88875     } catch (...) {
88876       {
88877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88878       };
88879     }
88880   }
88881 }
88882
88883
88884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88885   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88886   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
88887
88888   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88889   arg2 = (void (*)(Dali::Actor,bool))jarg2;
88890   {
88891     try {
88892       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
88893     } catch (std::out_of_range& e) {
88894       {
88895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88896       };
88897     } catch (std::exception& e) {
88898       {
88899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88900       };
88901     } catch (...) {
88902       {
88903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88904       };
88905     }
88906   }
88907 }
88908
88909
88910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
88911   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88912   Dali::Actor arg2 ;
88913   bool arg3 ;
88914   Dali::Actor *argp2 ;
88915
88916   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88917   argp2 = (Dali::Actor *)jarg2;
88918   if (!argp2) {
88919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88920     return ;
88921   }
88922   arg2 = *argp2;
88923   arg3 = jarg3 ? true : false;
88924   {
88925     try {
88926       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
88927     } catch (std::out_of_range& e) {
88928       {
88929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88930       };
88931     } catch (std::exception& e) {
88932       {
88933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88934       };
88935     } catch (...) {
88936       {
88937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88938       };
88939     }
88940   }
88941 }
88942
88943
88944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
88945   void * jresult ;
88946   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
88947
88948   {
88949     try {
88950       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
88951     } catch (std::out_of_range& e) {
88952       {
88953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88954       };
88955     } catch (std::exception& e) {
88956       {
88957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88958       };
88959     } catch (...) {
88960       {
88961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88962       };
88963     }
88964   }
88965   jresult = (void *)result;
88966   return jresult;
88967 }
88968
88969
88970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
88971   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88972
88973   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88974   {
88975     try {
88976       delete arg1;
88977     } catch (std::out_of_range& e) {
88978       {
88979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88980       };
88981     } catch (std::exception& e) {
88982       {
88983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88984       };
88985     } catch (...) {
88986       {
88987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88988       };
88989     }
88990   }
88991 }
88992
88993
88994 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
88995   unsigned int jresult ;
88996   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88997   bool result;
88998
88999   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89000   {
89001     try {
89002       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);
89003     } catch (std::out_of_range& e) {
89004       {
89005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89006       };
89007     } catch (std::exception& e) {
89008       {
89009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89010       };
89011     } catch (...) {
89012       {
89013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89014       };
89015     }
89016   }
89017   jresult = result;
89018   return jresult;
89019 }
89020
89021
89022 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
89023   unsigned long jresult ;
89024   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89025   std::size_t result;
89026
89027   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89028   {
89029     try {
89030       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);
89031     } catch (std::out_of_range& e) {
89032       {
89033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89034       };
89035     } catch (std::exception& e) {
89036       {
89037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89038       };
89039     } catch (...) {
89040       {
89041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89042       };
89043     }
89044   }
89045   jresult = (unsigned long)result;
89046   return jresult;
89047 }
89048
89049
89050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
89051   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89052   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
89053
89054   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89055   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
89056   {
89057     try {
89058       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
89059     } catch (std::out_of_range& e) {
89060       {
89061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89062       };
89063     } catch (std::exception& e) {
89064       {
89065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89066       };
89067     } catch (...) {
89068       {
89069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89070       };
89071     }
89072   }
89073 }
89074
89075
89076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89077   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89078   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
89079
89080   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89081   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
89082   {
89083     try {
89084       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
89085     } catch (std::out_of_range& e) {
89086       {
89087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89088       };
89089     } catch (std::exception& e) {
89090       {
89091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89092       };
89093     } catch (...) {
89094       {
89095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89096       };
89097     }
89098   }
89099 }
89100
89101
89102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
89103   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89104   Dali::Toolkit::StyleManager arg2 ;
89105   Dali::StyleChange::Type arg3 ;
89106   Dali::Toolkit::StyleManager *argp2 ;
89107
89108   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89109   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
89110   if (!argp2) {
89111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
89112     return ;
89113   }
89114   arg2 = *argp2;
89115   arg3 = (Dali::StyleChange::Type)jarg3;
89116   {
89117     try {
89118       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
89119     } catch (std::out_of_range& e) {
89120       {
89121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89122       };
89123     } catch (std::exception& e) {
89124       {
89125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89126       };
89127     } catch (...) {
89128       {
89129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89130       };
89131     }
89132   }
89133 }
89134
89135
89136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
89137   void * jresult ;
89138   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
89139
89140   {
89141     try {
89142       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
89143     } catch (std::out_of_range& e) {
89144       {
89145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89146       };
89147     } catch (std::exception& e) {
89148       {
89149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89150       };
89151     } catch (...) {
89152       {
89153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89154       };
89155     }
89156   }
89157   jresult = (void *)result;
89158   return jresult;
89159 }
89160
89161
89162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
89163   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89164
89165   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89166   {
89167     try {
89168       delete arg1;
89169     } catch (std::out_of_range& e) {
89170       {
89171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89172       };
89173     } catch (std::exception& e) {
89174       {
89175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89176       };
89177     } catch (...) {
89178       {
89179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89180       };
89181     }
89182   }
89183 }
89184
89185
89186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
89187   unsigned int jresult ;
89188   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89189   bool result;
89190
89191   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89192   {
89193     try {
89194       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
89195     } catch (std::out_of_range& e) {
89196       {
89197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89198       };
89199     } catch (std::exception& e) {
89200       {
89201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89202       };
89203     } catch (...) {
89204       {
89205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89206       };
89207     }
89208   }
89209   jresult = result;
89210   return jresult;
89211 }
89212
89213
89214 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
89215   unsigned long jresult ;
89216   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89217   std::size_t result;
89218
89219   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89220   {
89221     try {
89222       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
89223     } catch (std::out_of_range& e) {
89224       {
89225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89226       };
89227     } catch (std::exception& e) {
89228       {
89229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89230       };
89231     } catch (...) {
89232       {
89233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89234       };
89235     }
89236   }
89237   jresult = (unsigned long)result;
89238   return jresult;
89239 }
89240
89241
89242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
89243   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89244   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89245
89246   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89247   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89248   {
89249     try {
89250       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
89251     } catch (std::out_of_range& e) {
89252       {
89253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89254       };
89255     } catch (std::exception& e) {
89256       {
89257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89258       };
89259     } catch (...) {
89260       {
89261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89262       };
89263     }
89264   }
89265 }
89266
89267
89268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
89269   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89270   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89271
89272   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89273   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89274   {
89275     try {
89276       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
89277     } catch (std::out_of_range& e) {
89278       {
89279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89280       };
89281     } catch (std::exception& e) {
89282       {
89283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89284       };
89285     } catch (...) {
89286       {
89287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89288       };
89289     }
89290   }
89291 }
89292
89293
89294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
89295   unsigned int jresult ;
89296   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89297   Dali::Toolkit::Button arg2 ;
89298   Dali::Toolkit::Button *argp2 ;
89299   bool result;
89300
89301   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89302   argp2 = (Dali::Toolkit::Button *)jarg2;
89303   if (!argp2) {
89304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
89305     return 0;
89306   }
89307   arg2 = *argp2;
89308   {
89309     try {
89310       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
89311     } catch (std::out_of_range& e) {
89312       {
89313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89314       };
89315     } catch (std::exception& e) {
89316       {
89317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89318       };
89319     } catch (...) {
89320       {
89321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89322       };
89323     }
89324   }
89325   jresult = result;
89326   return jresult;
89327 }
89328
89329
89330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
89331   void * jresult ;
89332   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
89333
89334   {
89335     try {
89336       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
89337     } catch (std::out_of_range& e) {
89338       {
89339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89340       };
89341     } catch (std::exception& e) {
89342       {
89343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89344       };
89345     } catch (...) {
89346       {
89347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89348       };
89349     }
89350   }
89351   jresult = (void *)result;
89352   return jresult;
89353 }
89354
89355
89356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
89357   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89358
89359   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89360   {
89361     try {
89362       delete arg1;
89363     } catch (std::out_of_range& e) {
89364       {
89365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89366       };
89367     } catch (std::exception& e) {
89368       {
89369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89370       };
89371     } catch (...) {
89372       {
89373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89374       };
89375     }
89376   }
89377 }
89378
89379
89380 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
89381   unsigned int jresult ;
89382   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89383   bool result;
89384
89385   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89386   {
89387     try {
89388       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89389     } catch (std::out_of_range& e) {
89390       {
89391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89392       };
89393     } catch (std::exception& e) {
89394       {
89395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89396       };
89397     } catch (...) {
89398       {
89399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89400       };
89401     }
89402   }
89403   jresult = result;
89404   return jresult;
89405 }
89406
89407
89408 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
89409   unsigned long jresult ;
89410   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89411   std::size_t result;
89412
89413   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89414   {
89415     try {
89416       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89417     } catch (std::out_of_range& e) {
89418       {
89419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89420       };
89421     } catch (std::exception& e) {
89422       {
89423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89424       };
89425     } catch (...) {
89426       {
89427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89428       };
89429     }
89430   }
89431   jresult = (unsigned long)result;
89432   return jresult;
89433 }
89434
89435
89436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
89437   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89438   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89439
89440   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89441   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89442   {
89443     try {
89444       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
89445     } catch (std::out_of_range& e) {
89446       {
89447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89448       };
89449     } catch (std::exception& e) {
89450       {
89451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89452       };
89453     } catch (...) {
89454       {
89455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89456       };
89457     }
89458   }
89459 }
89460
89461
89462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
89463   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89464   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89465
89466   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89467   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89468   {
89469     try {
89470       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
89471     } catch (std::out_of_range& e) {
89472       {
89473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89474       };
89475     } catch (std::exception& e) {
89476       {
89477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89478       };
89479     } catch (...) {
89480       {
89481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89482       };
89483     }
89484   }
89485 }
89486
89487
89488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
89489   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89490   Dali::Toolkit::GaussianBlurView arg2 ;
89491   Dali::Toolkit::GaussianBlurView *argp2 ;
89492
89493   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89494   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89495   if (!argp2) {
89496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
89497     return ;
89498   }
89499   arg2 = *argp2;
89500   {
89501     try {
89502       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
89503     } catch (std::out_of_range& e) {
89504       {
89505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89506       };
89507     } catch (std::exception& e) {
89508       {
89509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89510       };
89511     } catch (...) {
89512       {
89513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89514       };
89515     }
89516   }
89517 }
89518
89519
89520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
89521   void * jresult ;
89522   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
89523
89524   {
89525     try {
89526       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
89527     } catch (std::out_of_range& e) {
89528       {
89529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89530       };
89531     } catch (std::exception& e) {
89532       {
89533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89534       };
89535     } catch (...) {
89536       {
89537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89538       };
89539     }
89540   }
89541   jresult = (void *)result;
89542   return jresult;
89543 }
89544
89545
89546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
89547   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89548
89549   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89550   {
89551     try {
89552       delete arg1;
89553     } catch (std::out_of_range& e) {
89554       {
89555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89556       };
89557     } catch (std::exception& e) {
89558       {
89559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89560       };
89561     } catch (...) {
89562       {
89563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89564       };
89565     }
89566   }
89567 }
89568
89569
89570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
89571   unsigned int jresult ;
89572   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89573   bool result;
89574
89575   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89576   {
89577     try {
89578       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);
89579     } catch (std::out_of_range& e) {
89580       {
89581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89582       };
89583     } catch (std::exception& e) {
89584       {
89585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89586       };
89587     } catch (...) {
89588       {
89589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89590       };
89591     }
89592   }
89593   jresult = result;
89594   return jresult;
89595 }
89596
89597
89598 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
89599   unsigned long jresult ;
89600   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89601   std::size_t result;
89602
89603   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89604   {
89605     try {
89606       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);
89607     } catch (std::out_of_range& e) {
89608       {
89609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89610       };
89611     } catch (std::exception& e) {
89612       {
89613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89614       };
89615     } catch (...) {
89616       {
89617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89618       };
89619     }
89620   }
89621   jresult = (unsigned long)result;
89622   return jresult;
89623 }
89624
89625
89626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
89627   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89628   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89629
89630   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89631   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89632   {
89633     try {
89634       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
89635     } catch (std::out_of_range& e) {
89636       {
89637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89638       };
89639     } catch (std::exception& e) {
89640       {
89641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89642       };
89643     } catch (...) {
89644       {
89645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89646       };
89647     }
89648   }
89649 }
89650
89651
89652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
89653   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89654   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89655
89656   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89657   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89658   {
89659     try {
89660       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89661     } catch (std::out_of_range& e) {
89662       {
89663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89664       };
89665     } catch (std::exception& e) {
89666       {
89667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89668       };
89669     } catch (...) {
89670       {
89671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89672       };
89673     }
89674   }
89675 }
89676
89677
89678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
89679   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89680   Dali::Toolkit::PageTurnView arg2 ;
89681   unsigned int arg3 ;
89682   bool arg4 ;
89683   Dali::Toolkit::PageTurnView *argp2 ;
89684
89685   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89686   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89687   if (!argp2) {
89688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89689     return ;
89690   }
89691   arg2 = *argp2;
89692   arg3 = (unsigned int)jarg3;
89693   arg4 = jarg4 ? true : false;
89694   {
89695     try {
89696       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
89697     } catch (std::out_of_range& e) {
89698       {
89699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89700       };
89701     } catch (std::exception& e) {
89702       {
89703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89704       };
89705     } catch (...) {
89706       {
89707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89708       };
89709     }
89710   }
89711 }
89712
89713
89714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
89715   void * jresult ;
89716   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
89717
89718   {
89719     try {
89720       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
89721     } catch (std::out_of_range& e) {
89722       {
89723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89724       };
89725     } catch (std::exception& e) {
89726       {
89727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89728       };
89729     } catch (...) {
89730       {
89731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89732       };
89733     }
89734   }
89735   jresult = (void *)result;
89736   return jresult;
89737 }
89738
89739
89740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
89741   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89742
89743   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89744   {
89745     try {
89746       delete arg1;
89747     } catch (std::out_of_range& e) {
89748       {
89749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89750       };
89751     } catch (std::exception& e) {
89752       {
89753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89754       };
89755     } catch (...) {
89756       {
89757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89758       };
89759     }
89760   }
89761 }
89762
89763
89764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
89765   unsigned int jresult ;
89766   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89767   bool result;
89768
89769   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89770   {
89771     try {
89772       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
89773     } catch (std::out_of_range& e) {
89774       {
89775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89776       };
89777     } catch (std::exception& e) {
89778       {
89779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89780       };
89781     } catch (...) {
89782       {
89783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89784       };
89785     }
89786   }
89787   jresult = result;
89788   return jresult;
89789 }
89790
89791
89792 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
89793   unsigned long jresult ;
89794   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89795   std::size_t result;
89796
89797   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89798   {
89799     try {
89800       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
89801     } catch (std::out_of_range& e) {
89802       {
89803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89804       };
89805     } catch (std::exception& e) {
89806       {
89807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89808       };
89809     } catch (...) {
89810       {
89811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89812       };
89813     }
89814   }
89815   jresult = (unsigned long)result;
89816   return jresult;
89817 }
89818
89819
89820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
89821   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89822   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
89823
89824   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89825   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
89826   {
89827     try {
89828       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
89829     } catch (std::out_of_range& e) {
89830       {
89831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89832       };
89833     } catch (std::exception& e) {
89834       {
89835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89836       };
89837     } catch (...) {
89838       {
89839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89840       };
89841     }
89842   }
89843 }
89844
89845
89846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
89847   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89848   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
89849
89850   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89851   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
89852   {
89853     try {
89854       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
89855     } catch (std::out_of_range& e) {
89856       {
89857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89858       };
89859     } catch (std::exception& e) {
89860       {
89861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89862       };
89863     } catch (...) {
89864       {
89865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89866       };
89867     }
89868   }
89869 }
89870
89871
89872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
89873   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89874   Dali::Toolkit::PageTurnView arg2 ;
89875   Dali::Toolkit::PageTurnView *argp2 ;
89876
89877   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89878   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89879   if (!argp2) {
89880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89881     return ;
89882   }
89883   arg2 = *argp2;
89884   {
89885     try {
89886       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
89887     } catch (std::out_of_range& e) {
89888       {
89889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89890       };
89891     } catch (std::exception& e) {
89892       {
89893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89894       };
89895     } catch (...) {
89896       {
89897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89898       };
89899     }
89900   }
89901 }
89902
89903
89904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
89905   void * jresult ;
89906   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
89907
89908   {
89909     try {
89910       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
89911     } catch (std::out_of_range& e) {
89912       {
89913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89914       };
89915     } catch (std::exception& e) {
89916       {
89917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89918       };
89919     } catch (...) {
89920       {
89921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89922       };
89923     }
89924   }
89925   jresult = (void *)result;
89926   return jresult;
89927 }
89928
89929
89930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
89931   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89932
89933   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89934   {
89935     try {
89936       delete arg1;
89937     } catch (std::out_of_range& e) {
89938       {
89939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89940       };
89941     } catch (std::exception& e) {
89942       {
89943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89944       };
89945     } catch (...) {
89946       {
89947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89948       };
89949     }
89950   }
89951 }
89952
89953
89954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
89955   unsigned int jresult ;
89956   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89957   bool result;
89958
89959   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89960   {
89961     try {
89962       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);
89963     } catch (std::out_of_range& e) {
89964       {
89965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89966       };
89967     } catch (std::exception& e) {
89968       {
89969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89970       };
89971     } catch (...) {
89972       {
89973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89974       };
89975     }
89976   }
89977   jresult = result;
89978   return jresult;
89979 }
89980
89981
89982 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
89983   unsigned long jresult ;
89984   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89985   std::size_t result;
89986
89987   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89988   {
89989     try {
89990       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);
89991     } catch (std::out_of_range& e) {
89992       {
89993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89994       };
89995     } catch (std::exception& e) {
89996       {
89997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89998       };
89999     } catch (...) {
90000       {
90001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90002       };
90003     }
90004   }
90005   jresult = (unsigned long)result;
90006   return jresult;
90007 }
90008
90009
90010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
90011   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90012   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
90013
90014   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90015   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
90016   {
90017     try {
90018       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
90019     } catch (std::out_of_range& e) {
90020       {
90021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90022       };
90023     } catch (std::exception& e) {
90024       {
90025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90026       };
90027     } catch (...) {
90028       {
90029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90030       };
90031     }
90032   }
90033 }
90034
90035
90036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90037   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90038   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
90039
90040   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90041   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
90042   {
90043     try {
90044       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
90045     } catch (std::out_of_range& e) {
90046       {
90047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90048       };
90049     } catch (std::exception& e) {
90050       {
90051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90052       };
90053     } catch (...) {
90054       {
90055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90056       };
90057     }
90058   }
90059 }
90060
90061
90062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
90063   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90064   Dali::Toolkit::ProgressBar arg2 ;
90065   float arg3 ;
90066   float arg4 ;
90067   Dali::Toolkit::ProgressBar *argp2 ;
90068
90069   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90070   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
90071   if (!argp2) {
90072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
90073     return ;
90074   }
90075   arg2 = *argp2;
90076   arg3 = (float)jarg3;
90077   arg4 = (float)jarg4;
90078   {
90079     try {
90080       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
90081     } catch (std::out_of_range& e) {
90082       {
90083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90084       };
90085     } catch (std::exception& e) {
90086       {
90087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90088       };
90089     } catch (...) {
90090       {
90091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90092       };
90093     }
90094   }
90095 }
90096
90097
90098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
90099   void * jresult ;
90100   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
90101
90102   {
90103     try {
90104       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
90105     } catch (std::out_of_range& e) {
90106       {
90107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90108       };
90109     } catch (std::exception& e) {
90110       {
90111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90112       };
90113     } catch (...) {
90114       {
90115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90116       };
90117     }
90118   }
90119   jresult = (void *)result;
90120   return jresult;
90121 }
90122
90123
90124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
90125   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90126
90127   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90128   {
90129     try {
90130       delete arg1;
90131     } catch (std::out_of_range& e) {
90132       {
90133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90134       };
90135     } catch (std::exception& e) {
90136       {
90137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90138       };
90139     } catch (...) {
90140       {
90141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90142       };
90143     }
90144   }
90145 }
90146
90147
90148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
90149   unsigned int jresult ;
90150   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90151   bool result;
90152
90153   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90154   {
90155     try {
90156       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);
90157     } catch (std::out_of_range& e) {
90158       {
90159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90160       };
90161     } catch (std::exception& e) {
90162       {
90163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90164       };
90165     } catch (...) {
90166       {
90167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90168       };
90169     }
90170   }
90171   jresult = result;
90172   return jresult;
90173 }
90174
90175
90176 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
90177   unsigned long jresult ;
90178   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90179   std::size_t result;
90180
90181   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90182   {
90183     try {
90184       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);
90185     } catch (std::out_of_range& e) {
90186       {
90187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90188       };
90189     } catch (std::exception& e) {
90190       {
90191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90192       };
90193     } catch (...) {
90194       {
90195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90196       };
90197     }
90198   }
90199   jresult = (unsigned long)result;
90200   return jresult;
90201 }
90202
90203
90204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
90205   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90206   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90207
90208   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90209   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90210   {
90211     try {
90212       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90213     } catch (std::out_of_range& e) {
90214       {
90215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90216       };
90217     } catch (std::exception& e) {
90218       {
90219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90220       };
90221     } catch (...) {
90222       {
90223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90224       };
90225     }
90226   }
90227 }
90228
90229
90230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
90231   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90232   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90233
90234   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90235   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90236   {
90237     try {
90238       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90239     } catch (std::out_of_range& e) {
90240       {
90241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90242       };
90243     } catch (std::exception& e) {
90244       {
90245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90246       };
90247     } catch (...) {
90248       {
90249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90250       };
90251     }
90252   }
90253 }
90254
90255
90256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
90257   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90258   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
90259
90260   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90261   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
90262   if (!arg2) {
90263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
90264     return ;
90265   }
90266   {
90267     try {
90268       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
90269     } catch (std::out_of_range& e) {
90270       {
90271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90272       };
90273     } catch (std::exception& e) {
90274       {
90275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90276       };
90277     } catch (...) {
90278       {
90279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90280       };
90281     }
90282   }
90283 }
90284
90285
90286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
90287   void * jresult ;
90288   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
90289
90290   {
90291     try {
90292       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
90293     } catch (std::out_of_range& e) {
90294       {
90295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90296       };
90297     } catch (std::exception& e) {
90298       {
90299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90300       };
90301     } catch (...) {
90302       {
90303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90304       };
90305     }
90306   }
90307   jresult = (void *)result;
90308   return jresult;
90309 }
90310
90311
90312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
90313   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90314
90315   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90316   {
90317     try {
90318       delete arg1;
90319     } catch (std::out_of_range& e) {
90320       {
90321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90322       };
90323     } catch (std::exception& e) {
90324       {
90325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90326       };
90327     } catch (...) {
90328       {
90329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90330       };
90331     }
90332   }
90333 }
90334
90335
90336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
90337   unsigned int jresult ;
90338   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90339   bool result;
90340
90341   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90342   {
90343     try {
90344       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90345     } catch (std::out_of_range& e) {
90346       {
90347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90348       };
90349     } catch (std::exception& e) {
90350       {
90351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90352       };
90353     } catch (...) {
90354       {
90355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90356       };
90357     }
90358   }
90359   jresult = result;
90360   return jresult;
90361 }
90362
90363
90364 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
90365   unsigned long jresult ;
90366   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90367   std::size_t result;
90368
90369   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90370   {
90371     try {
90372       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90373     } catch (std::out_of_range& e) {
90374       {
90375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90376       };
90377     } catch (std::exception& e) {
90378       {
90379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90380       };
90381     } catch (...) {
90382       {
90383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90384       };
90385     }
90386   }
90387   jresult = (unsigned long)result;
90388   return jresult;
90389 }
90390
90391
90392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
90393   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90394   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90395
90396   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90397   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90398   {
90399     try {
90400       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90401     } catch (std::out_of_range& e) {
90402       {
90403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90404       };
90405     } catch (std::exception& e) {
90406       {
90407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90408       };
90409     } catch (...) {
90410       {
90411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90412       };
90413     }
90414   }
90415 }
90416
90417
90418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
90419   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90420   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90421
90422   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90423   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90424   {
90425     try {
90426       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90427     } catch (std::out_of_range& e) {
90428       {
90429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90430       };
90431     } catch (std::exception& e) {
90432       {
90433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90434       };
90435     } catch (...) {
90436       {
90437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90438       };
90439     }
90440   }
90441 }
90442
90443
90444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
90445   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90446   Dali::Vector2 *arg2 = 0 ;
90447
90448   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90449   arg2 = (Dali::Vector2 *)jarg2;
90450   if (!arg2) {
90451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90452     return ;
90453   }
90454   {
90455     try {
90456       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
90457     } catch (std::out_of_range& e) {
90458       {
90459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90460       };
90461     } catch (std::exception& e) {
90462       {
90463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90464       };
90465     } catch (...) {
90466       {
90467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90468       };
90469     }
90470   }
90471 }
90472
90473
90474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
90475   void * jresult ;
90476   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
90477
90478   {
90479     try {
90480       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
90481     } catch (std::out_of_range& e) {
90482       {
90483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90484       };
90485     } catch (std::exception& e) {
90486       {
90487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90488       };
90489     } catch (...) {
90490       {
90491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90492       };
90493     }
90494   }
90495   jresult = (void *)result;
90496   return jresult;
90497 }
90498
90499
90500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
90501   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90502
90503   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90504   {
90505     try {
90506       delete arg1;
90507     } catch (std::out_of_range& e) {
90508       {
90509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90510       };
90511     } catch (std::exception& e) {
90512       {
90513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90514       };
90515     } catch (...) {
90516       {
90517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90518       };
90519     }
90520   }
90521 }
90522
90523
90524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) {
90525   unsigned int jresult ;
90526   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90527   bool result;
90528
90529   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90530   {
90531     try {
90532       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90533     } catch (std::out_of_range& e) {
90534       {
90535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90536       };
90537     } catch (std::exception& e) {
90538       {
90539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90540       };
90541     } catch (...) {
90542       {
90543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90544       };
90545     }
90546   }
90547   jresult = result;
90548   return jresult;
90549 }
90550
90551
90552 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) {
90553   unsigned long jresult ;
90554   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90555   std::size_t result;
90556
90557   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90558   {
90559     try {
90560       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90561     } catch (std::out_of_range& e) {
90562       {
90563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90564       };
90565     } catch (std::exception& e) {
90566       {
90567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90568       };
90569     } catch (...) {
90570       {
90571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90572       };
90573     }
90574   }
90575   jresult = (unsigned long)result;
90576   return jresult;
90577 }
90578
90579
90580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
90581   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90582   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90583
90584   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90585   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90586   {
90587     try {
90588       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
90589     } catch (std::out_of_range& e) {
90590       {
90591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90592       };
90593     } catch (std::exception& e) {
90594       {
90595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90596       };
90597     } catch (...) {
90598       {
90599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90600       };
90601     }
90602   }
90603 }
90604
90605
90606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
90607   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90608   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90609
90610   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90611   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90612   {
90613     try {
90614       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
90615     } catch (std::out_of_range& e) {
90616       {
90617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90618       };
90619     } catch (std::exception& e) {
90620       {
90621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90622       };
90623     } catch (...) {
90624       {
90625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90626       };
90627     }
90628   }
90629 }
90630
90631
90632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
90633   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90634   Dali::Toolkit::TextEditor arg2 ;
90635   Dali::Toolkit::TextEditor *argp2 ;
90636
90637   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90638   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
90639   if (!argp2) {
90640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
90641     return ;
90642   }
90643   arg2 = *argp2;
90644   {
90645     try {
90646       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
90647     } catch (std::out_of_range& e) {
90648       {
90649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90650       };
90651     } catch (std::exception& e) {
90652       {
90653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90654       };
90655     } catch (...) {
90656       {
90657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90658       };
90659     }
90660   }
90661 }
90662
90663
90664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() {
90665   void * jresult ;
90666   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
90667
90668   {
90669     try {
90670       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
90671     } catch (std::out_of_range& e) {
90672       {
90673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90674       };
90675     } catch (std::exception& e) {
90676       {
90677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90678       };
90679     } catch (...) {
90680       {
90681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90682       };
90683     }
90684   }
90685   jresult = (void *)result;
90686   return jresult;
90687 }
90688
90689
90690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) {
90691   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90692
90693   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90694   {
90695     try {
90696       delete arg1;
90697     } catch (std::out_of_range& e) {
90698       {
90699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90700       };
90701     } catch (std::exception& e) {
90702       {
90703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90704       };
90705     } catch (...) {
90706       {
90707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90708       };
90709     }
90710   }
90711 }
90712
90713
90714 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) {
90715   unsigned int jresult ;
90716   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90717   bool result;
90718
90719   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90720   {
90721     try {
90722       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90723     } catch (std::out_of_range& e) {
90724       {
90725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90726       };
90727     } catch (std::exception& e) {
90728       {
90729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90730       };
90731     } catch (...) {
90732       {
90733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90734       };
90735     }
90736   }
90737   jresult = result;
90738   return jresult;
90739 }
90740
90741
90742 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) {
90743   unsigned long jresult ;
90744   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90745   std::size_t result;
90746
90747   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90748   {
90749     try {
90750       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90751     } catch (std::out_of_range& e) {
90752       {
90753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90754       };
90755     } catch (std::exception& e) {
90756       {
90757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90758       };
90759     } catch (...) {
90760       {
90761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90762       };
90763     }
90764   }
90765   jresult = (unsigned long)result;
90766   return jresult;
90767 }
90768
90769
90770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
90771   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90772   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
90773
90774   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90775   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
90776   {
90777     try {
90778       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
90779     } catch (std::out_of_range& e) {
90780       {
90781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90782       };
90783     } catch (std::exception& e) {
90784       {
90785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90786       };
90787     } catch (...) {
90788       {
90789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90790       };
90791     }
90792   }
90793 }
90794
90795
90796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
90797   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90798   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
90799
90800   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90801   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
90802   {
90803     try {
90804       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
90805     } catch (std::out_of_range& e) {
90806       {
90807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90808       };
90809     } catch (std::exception& e) {
90810       {
90811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90812       };
90813     } catch (...) {
90814       {
90815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90816       };
90817     }
90818   }
90819 }
90820
90821
90822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
90823   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90824   Dali::Toolkit::TextField arg2 ;
90825   Dali::Toolkit::TextField *argp2 ;
90826
90827   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90828   argp2 = (Dali::Toolkit::TextField *)jarg2;
90829   if (!argp2) {
90830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
90831     return ;
90832   }
90833   arg2 = *argp2;
90834   {
90835     try {
90836       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
90837     } catch (std::out_of_range& e) {
90838       {
90839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90840       };
90841     } catch (std::exception& e) {
90842       {
90843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90844       };
90845     } catch (...) {
90846       {
90847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90848       };
90849     }
90850   }
90851 }
90852
90853
90854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() {
90855   void * jresult ;
90856   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
90857
90858   {
90859     try {
90860       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
90861     } catch (std::out_of_range& e) {
90862       {
90863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90864       };
90865     } catch (std::exception& e) {
90866       {
90867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90868       };
90869     } catch (...) {
90870       {
90871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90872       };
90873     }
90874   }
90875   jresult = (void *)result;
90876   return jresult;
90877 }
90878
90879
90880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) {
90881   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90882
90883   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90884   {
90885     try {
90886       delete arg1;
90887     } catch (std::out_of_range& e) {
90888       {
90889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90890       };
90891     } catch (std::exception& e) {
90892       {
90893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90894       };
90895     } catch (...) {
90896       {
90897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90898       };
90899     }
90900   }
90901 }
90902
90903
90904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
90905   unsigned int jresult ;
90906   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90907   bool result;
90908
90909   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90910   {
90911     try {
90912       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);
90913     } catch (std::out_of_range& e) {
90914       {
90915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90916       };
90917     } catch (std::exception& e) {
90918       {
90919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90920       };
90921     } catch (...) {
90922       {
90923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90924       };
90925     }
90926   }
90927   jresult = result;
90928   return jresult;
90929 }
90930
90931
90932 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
90933   unsigned long jresult ;
90934   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90935   std::size_t result;
90936
90937   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90938   {
90939     try {
90940       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);
90941     } catch (std::out_of_range& e) {
90942       {
90943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90944       };
90945     } catch (std::exception& e) {
90946       {
90947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90948       };
90949     } catch (...) {
90950       {
90951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90952       };
90953     }
90954   }
90955   jresult = (unsigned long)result;
90956   return jresult;
90957 }
90958
90959
90960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
90961   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90962   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
90963
90964   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90965   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
90966   {
90967     try {
90968       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90969     } catch (std::out_of_range& e) {
90970       {
90971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90972       };
90973     } catch (std::exception& e) {
90974       {
90975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90976       };
90977     } catch (...) {
90978       {
90979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90980       };
90981     }
90982   }
90983 }
90984
90985
90986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
90987   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90988   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
90989
90990   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90991   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
90992   {
90993     try {
90994       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90995     } catch (std::out_of_range& e) {
90996       {
90997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90998       };
90999     } catch (std::exception& e) {
91000       {
91001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91002       };
91003     } catch (...) {
91004       {
91005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91006       };
91007     }
91008   }
91009 }
91010
91011
91012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
91013   unsigned int jresult ;
91014   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91015   Dali::Toolkit::Control arg2 ;
91016   Dali::KeyEvent *arg3 = 0 ;
91017   Dali::Toolkit::Control *argp2 ;
91018   bool result;
91019
91020   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91021   argp2 = (Dali::Toolkit::Control *)jarg2;
91022   if (!argp2) {
91023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91024     return 0;
91025   }
91026   arg2 = *argp2;
91027   arg3 = (Dali::KeyEvent *)jarg3;
91028   if (!arg3) {
91029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
91030     return 0;
91031   }
91032   {
91033     try {
91034       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);
91035     } catch (std::out_of_range& e) {
91036       {
91037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91038       };
91039     } catch (std::exception& e) {
91040       {
91041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91042       };
91043     } catch (...) {
91044       {
91045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91046       };
91047     }
91048   }
91049   jresult = result;
91050   return jresult;
91051 }
91052
91053
91054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
91055   void * jresult ;
91056   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
91057
91058   {
91059     try {
91060       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
91061     } catch (std::out_of_range& e) {
91062       {
91063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91064       };
91065     } catch (std::exception& e) {
91066       {
91067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91068       };
91069     } catch (...) {
91070       {
91071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91072       };
91073     }
91074   }
91075   jresult = (void *)result;
91076   return jresult;
91077 }
91078
91079
91080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
91081   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91082
91083   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91084   {
91085     try {
91086       delete arg1;
91087     } catch (std::out_of_range& e) {
91088       {
91089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91090       };
91091     } catch (std::exception& e) {
91092       {
91093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91094       };
91095     } catch (...) {
91096       {
91097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91098       };
91099     }
91100   }
91101 }
91102
91103
91104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
91105   unsigned int jresult ;
91106   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91107   bool result;
91108
91109   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91110   {
91111     try {
91112       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
91113     } catch (std::out_of_range& e) {
91114       {
91115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91116       };
91117     } catch (std::exception& e) {
91118       {
91119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91120       };
91121     } catch (...) {
91122       {
91123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91124       };
91125     }
91126   }
91127   jresult = result;
91128   return jresult;
91129 }
91130
91131
91132 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
91133   unsigned long jresult ;
91134   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91135   std::size_t result;
91136
91137   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91138   {
91139     try {
91140       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
91141     } catch (std::out_of_range& e) {
91142       {
91143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91144       };
91145     } catch (std::exception& e) {
91146       {
91147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91148       };
91149     } catch (...) {
91150       {
91151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91152       };
91153     }
91154   }
91155   jresult = (unsigned long)result;
91156   return jresult;
91157 }
91158
91159
91160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
91161   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91162   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91163
91164   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91165   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91166   {
91167     try {
91168       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
91169     } catch (std::out_of_range& e) {
91170       {
91171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91172       };
91173     } catch (std::exception& e) {
91174       {
91175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91176       };
91177     } catch (...) {
91178       {
91179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91180       };
91181     }
91182   }
91183 }
91184
91185
91186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
91187   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91188   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91189
91190   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91191   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91192   {
91193     try {
91194       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
91195     } catch (std::out_of_range& e) {
91196       {
91197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91198       };
91199     } catch (std::exception& e) {
91200       {
91201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91202       };
91203     } catch (...) {
91204       {
91205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91206       };
91207     }
91208   }
91209 }
91210
91211
91212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
91213   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91214   Dali::Toolkit::Control arg2 ;
91215   Dali::Toolkit::Control *argp2 ;
91216
91217   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91218   argp2 = (Dali::Toolkit::Control *)jarg2;
91219   if (!argp2) {
91220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91221     return ;
91222   }
91223   arg2 = *argp2;
91224   {
91225     try {
91226       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
91227     } catch (std::out_of_range& e) {
91228       {
91229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91230       };
91231     } catch (std::exception& e) {
91232       {
91233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91234       };
91235     } catch (...) {
91236       {
91237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91238       };
91239     }
91240   }
91241 }
91242
91243
91244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
91245   void * jresult ;
91246   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
91247
91248   {
91249     try {
91250       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
91251     } catch (std::out_of_range& e) {
91252       {
91253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91254       };
91255     } catch (std::exception& e) {
91256       {
91257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91258       };
91259     } catch (...) {
91260       {
91261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91262       };
91263     }
91264   }
91265   jresult = (void *)result;
91266   return jresult;
91267 }
91268
91269
91270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
91271   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91272
91273   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91274   {
91275     try {
91276       delete arg1;
91277     } catch (std::out_of_range& e) {
91278       {
91279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91280       };
91281     } catch (std::exception& e) {
91282       {
91283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91284       };
91285     } catch (...) {
91286       {
91287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91288       };
91289     }
91290   }
91291 }
91292
91293
91294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
91295   unsigned int jresult ;
91296   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91297   bool result;
91298
91299   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91300   {
91301     try {
91302       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91303     } catch (std::out_of_range& e) {
91304       {
91305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91306       };
91307     } catch (std::exception& e) {
91308       {
91309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91310       };
91311     } catch (...) {
91312       {
91313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91314       };
91315     }
91316   }
91317   jresult = result;
91318   return jresult;
91319 }
91320
91321
91322 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
91323   unsigned long jresult ;
91324   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91325   std::size_t result;
91326
91327   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91328   {
91329     try {
91330       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91331     } catch (std::out_of_range& e) {
91332       {
91333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91334       };
91335     } catch (std::exception& e) {
91336       {
91337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91338       };
91339     } catch (...) {
91340       {
91341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91342       };
91343     }
91344   }
91345   jresult = (unsigned long)result;
91346   return jresult;
91347 }
91348
91349
91350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
91351   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91352   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91353
91354   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91355   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91356   {
91357     try {
91358       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
91359     } catch (std::out_of_range& e) {
91360       {
91361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91362       };
91363     } catch (std::exception& e) {
91364       {
91365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91366       };
91367     } catch (...) {
91368       {
91369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91370       };
91371     }
91372   }
91373 }
91374
91375
91376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
91377   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91378   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91379
91380   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91381   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91382   {
91383     try {
91384       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
91385     } catch (std::out_of_range& e) {
91386       {
91387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91388       };
91389     } catch (std::exception& e) {
91390       {
91391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91392       };
91393     } catch (...) {
91394       {
91395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91396       };
91397     }
91398   }
91399 }
91400
91401
91402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
91403   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91404   Dali::Toolkit::VideoView *arg2 = 0 ;
91405
91406   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91407   arg2 = (Dali::Toolkit::VideoView *)jarg2;
91408   if (!arg2) {
91409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
91410     return ;
91411   }
91412   {
91413     try {
91414       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
91415     } catch (std::out_of_range& e) {
91416       {
91417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91418       };
91419     } catch (std::exception& e) {
91420       {
91421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91422       };
91423     } catch (...) {
91424       {
91425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91426       };
91427     }
91428   }
91429 }
91430
91431
91432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
91433   void * jresult ;
91434   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
91435
91436   {
91437     try {
91438       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
91439     } catch (std::out_of_range& e) {
91440       {
91441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91442       };
91443     } catch (std::exception& e) {
91444       {
91445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91446       };
91447     } catch (...) {
91448       {
91449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91450       };
91451     }
91452   }
91453   jresult = (void *)result;
91454   return jresult;
91455 }
91456
91457
91458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
91459   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91460
91461   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91462   {
91463     try {
91464       delete arg1;
91465     } catch (std::out_of_range& e) {
91466       {
91467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91468       };
91469     } catch (std::exception& e) {
91470       {
91471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91472       };
91473     } catch (...) {
91474       {
91475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91476       };
91477     }
91478   }
91479 }
91480
91481
91482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
91483   unsigned int jresult ;
91484   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91485   bool result;
91486
91487   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91488   {
91489     try {
91490       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91491     } catch (std::out_of_range& e) {
91492       {
91493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91494       };
91495     } catch (std::exception& e) {
91496       {
91497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91498       };
91499     } catch (...) {
91500       {
91501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91502       };
91503     }
91504   }
91505   jresult = result;
91506   return jresult;
91507 }
91508
91509
91510 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
91511   unsigned long jresult ;
91512   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91513   std::size_t result;
91514
91515   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91516   {
91517     try {
91518       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91519     } catch (std::out_of_range& e) {
91520       {
91521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91522       };
91523     } catch (std::exception& e) {
91524       {
91525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91526       };
91527     } catch (...) {
91528       {
91529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91530       };
91531     }
91532   }
91533   jresult = (unsigned long)result;
91534   return jresult;
91535 }
91536
91537
91538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
91539   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91540   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91541
91542   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91543   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91544   {
91545     try {
91546       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
91547     } catch (std::out_of_range& e) {
91548       {
91549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91550       };
91551     } catch (std::exception& e) {
91552       {
91553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91554       };
91555     } catch (...) {
91556       {
91557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91558       };
91559     }
91560   }
91561 }
91562
91563
91564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91565   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91566   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91567
91568   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91569   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91570   {
91571     try {
91572       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
91573     } catch (std::out_of_range& e) {
91574       {
91575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91576       };
91577     } catch (std::exception& e) {
91578       {
91579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91580       };
91581     } catch (...) {
91582       {
91583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91584       };
91585     }
91586   }
91587 }
91588
91589
91590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
91591   unsigned int jresult ;
91592   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91593   Dali::Toolkit::Slider arg2 ;
91594   float arg3 ;
91595   Dali::Toolkit::Slider *argp2 ;
91596   bool result;
91597
91598   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91599   argp2 = (Dali::Toolkit::Slider *)jarg2;
91600   if (!argp2) {
91601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
91602     return 0;
91603   }
91604   arg2 = *argp2;
91605   arg3 = (float)jarg3;
91606   {
91607     try {
91608       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
91609     } catch (std::out_of_range& e) {
91610       {
91611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91612       };
91613     } catch (std::exception& e) {
91614       {
91615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91616       };
91617     } catch (...) {
91618       {
91619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91620       };
91621     }
91622   }
91623   jresult = result;
91624   return jresult;
91625 }
91626
91627
91628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
91629   void * jresult ;
91630   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
91631
91632   {
91633     try {
91634       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
91635     } catch (std::out_of_range& e) {
91636       {
91637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91638       };
91639     } catch (std::exception& e) {
91640       {
91641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91642       };
91643     } catch (...) {
91644       {
91645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91646       };
91647     }
91648   }
91649   jresult = (void *)result;
91650   return jresult;
91651 }
91652
91653
91654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
91655   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91656
91657   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91658   {
91659     try {
91660       delete arg1;
91661     } catch (std::out_of_range& e) {
91662       {
91663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91664       };
91665     } catch (std::exception& e) {
91666       {
91667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91668       };
91669     } catch (...) {
91670       {
91671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91672       };
91673     }
91674   }
91675 }
91676
91677
91678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
91679   unsigned int jresult ;
91680   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91681   bool result;
91682
91683   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91684   {
91685     try {
91686       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91687     } catch (std::out_of_range& e) {
91688       {
91689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91690       };
91691     } catch (std::exception& e) {
91692       {
91693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91694       };
91695     } catch (...) {
91696       {
91697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91698       };
91699     }
91700   }
91701   jresult = result;
91702   return jresult;
91703 }
91704
91705
91706 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
91707   unsigned long jresult ;
91708   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91709   std::size_t result;
91710
91711   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91712   {
91713     try {
91714       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91715     } catch (std::out_of_range& e) {
91716       {
91717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91718       };
91719     } catch (std::exception& e) {
91720       {
91721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91722       };
91723     } catch (...) {
91724       {
91725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91726       };
91727     }
91728   }
91729   jresult = (unsigned long)result;
91730   return jresult;
91731 }
91732
91733
91734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
91735   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91736   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
91737
91738   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91739   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
91740   {
91741     try {
91742       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
91743     } catch (std::out_of_range& e) {
91744       {
91745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91746       };
91747     } catch (std::exception& e) {
91748       {
91749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91750       };
91751     } catch (...) {
91752       {
91753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91754       };
91755     }
91756   }
91757 }
91758
91759
91760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
91761   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91762   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
91763
91764   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91765   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
91766   {
91767     try {
91768       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
91769     } catch (std::out_of_range& e) {
91770       {
91771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91772       };
91773     } catch (std::exception& e) {
91774       {
91775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91776       };
91777     } catch (...) {
91778       {
91779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91780       };
91781     }
91782   }
91783 }
91784
91785
91786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
91787   unsigned int jresult ;
91788   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91789   Dali::Toolkit::Slider arg2 ;
91790   int arg3 ;
91791   Dali::Toolkit::Slider *argp2 ;
91792   bool result;
91793
91794   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91795   argp2 = (Dali::Toolkit::Slider *)jarg2;
91796   if (!argp2) {
91797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
91798     return 0;
91799   }
91800   arg2 = *argp2;
91801   arg3 = (int)jarg3;
91802   {
91803     try {
91804       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
91805     } catch (std::out_of_range& e) {
91806       {
91807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91808       };
91809     } catch (std::exception& e) {
91810       {
91811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91812       };
91813     } catch (...) {
91814       {
91815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91816       };
91817     }
91818   }
91819   jresult = result;
91820   return jresult;
91821 }
91822
91823
91824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
91825   void * jresult ;
91826   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
91827
91828   {
91829     try {
91830       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
91831     } catch (std::out_of_range& e) {
91832       {
91833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91834       };
91835     } catch (std::exception& e) {
91836       {
91837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91838       };
91839     } catch (...) {
91840       {
91841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91842       };
91843     }
91844   }
91845   jresult = (void *)result;
91846   return jresult;
91847 }
91848
91849
91850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
91851   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91852
91853   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91854   {
91855     try {
91856       delete arg1;
91857     } catch (std::out_of_range& e) {
91858       {
91859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91860       };
91861     } catch (std::exception& e) {
91862       {
91863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91864       };
91865     } catch (...) {
91866       {
91867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91868       };
91869     }
91870   }
91871 }
91872
91873
91874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
91875   void * jresult ;
91876   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91877
91878   {
91879     try {
91880       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
91881     } catch (std::out_of_range& e) {
91882       {
91883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91884       };
91885     } catch (std::exception& e) {
91886       {
91887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91888       };
91889     } catch (...) {
91890       {
91891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91892       };
91893     }
91894   }
91895   jresult = (void *)result;
91896   return jresult;
91897 }
91898
91899
91900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
91901   void * jresult ;
91902   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
91903   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91904
91905   arg1 = (Dali::Toolkit::Ruler *)jarg1;
91906   {
91907     try {
91908       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
91909     } catch (std::out_of_range& e) {
91910       {
91911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91912       };
91913     } catch (std::exception& e) {
91914       {
91915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91916       };
91917     } catch (...) {
91918       {
91919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91920       };
91921     }
91922   }
91923   jresult = (void *)result;
91924   return jresult;
91925 }
91926
91927
91928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
91929   void * jresult ;
91930   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
91931   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91932
91933   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91934   if (!arg1) {
91935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
91936     return 0;
91937   }
91938   {
91939     try {
91940       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
91941     } catch (std::out_of_range& e) {
91942       {
91943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91944       };
91945     } catch (std::exception& e) {
91946       {
91947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91948       };
91949     } catch (...) {
91950       {
91951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91952       };
91953     }
91954   }
91955   jresult = (void *)result;
91956   return jresult;
91957 }
91958
91959
91960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
91961   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91962
91963   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91964   {
91965     try {
91966       delete arg1;
91967     } catch (std::out_of_range& e) {
91968       {
91969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91970       };
91971     } catch (std::exception& e) {
91972       {
91973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91974       };
91975     } catch (...) {
91976       {
91977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91978       };
91979     }
91980   }
91981 }
91982
91983
91984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
91985   void * jresult ;
91986   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91987   Dali::Toolkit::Ruler *result = 0 ;
91988
91989   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91990   {
91991     try {
91992       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
91993     } catch (std::out_of_range& e) {
91994       {
91995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91996       };
91997     } catch (std::exception& e) {
91998       {
91999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92000       };
92001     } catch (...) {
92002       {
92003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92004       };
92005     }
92006   }
92007   jresult = (void *)result;
92008   return jresult;
92009 }
92010
92011
92012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
92013   void * jresult ;
92014   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92015   Dali::Toolkit::Ruler *result = 0 ;
92016
92017   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92018   {
92019     try {
92020       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
92021     } catch (std::out_of_range& e) {
92022       {
92023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92024       };
92025     } catch (std::exception& e) {
92026       {
92027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92028       };
92029     } catch (...) {
92030       {
92031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92032       };
92033     }
92034   }
92035   jresult = (void *)result;
92036   return jresult;
92037 }
92038
92039
92040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
92041   void * jresult ;
92042   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92043   Dali::Toolkit::Ruler *result = 0 ;
92044
92045   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92046   {
92047     try {
92048       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
92049     } catch (std::out_of_range& e) {
92050       {
92051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92052       };
92053     } catch (std::exception& e) {
92054       {
92055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92056       };
92057     } catch (...) {
92058       {
92059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92060       };
92061     }
92062   }
92063   jresult = (void *)result;
92064   return jresult;
92065 }
92066
92067
92068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
92069   void * jresult ;
92070   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92071   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
92072   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92073
92074   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92075   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
92076   if (!arg2) {
92077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
92078     return 0;
92079   }
92080   {
92081     try {
92082       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
92083     } catch (std::out_of_range& e) {
92084       {
92085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92086       };
92087     } catch (std::exception& e) {
92088       {
92089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92090       };
92091     } catch (...) {
92092       {
92093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92094       };
92095     }
92096   }
92097   jresult = (void *)result;
92098   return jresult;
92099 }
92100
92101
92102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
92103   void * jresult ;
92104   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92105   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
92106   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92107
92108   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92109   arg2 = (Dali::Toolkit::Ruler *)jarg2;
92110   {
92111     try {
92112       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
92113     } catch (std::out_of_range& e) {
92114       {
92115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92116       };
92117     } catch (std::exception& e) {
92118       {
92119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92120       };
92121     } catch (...) {
92122       {
92123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92124       };
92125     }
92126   }
92127   jresult = (void *)result;
92128   return jresult;
92129 }
92130
92131
92132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
92133   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92134
92135   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92136   {
92137     try {
92138       (arg1)->Reset();
92139     } catch (std::out_of_range& e) {
92140       {
92141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92142       };
92143     } catch (std::exception& e) {
92144       {
92145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92146       };
92147     } catch (...) {
92148       {
92149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92150       };
92151     }
92152   }
92153 }
92154
92155
92156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
92157   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92158   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
92159
92160   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92161   arg2 = (Dali::Toolkit::Ruler *)jarg2;
92162   {
92163     try {
92164       (arg1)->Reset(arg2);
92165     } catch (std::out_of_range& e) {
92166       {
92167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92168       };
92169     } catch (std::exception& e) {
92170       {
92171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92172       };
92173     } catch (...) {
92174       {
92175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92176       };
92177     }
92178   }
92179 }
92180
92181
92182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
92183   void * jresult ;
92184   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92185   Dali::Toolkit::Ruler *result = 0 ;
92186
92187   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92188   {
92189     try {
92190       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
92191     } catch (std::out_of_range& e) {
92192       {
92193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92194       };
92195     } catch (std::exception& e) {
92196       {
92197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92198       };
92199     } catch (...) {
92200       {
92201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92202       };
92203     }
92204   }
92205   jresult = (void *)result;
92206   return jresult;
92207 }
92208
92209
92210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
92211   float jresult ;
92212   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92213   float arg2 ;
92214   float arg3 ;
92215   float result;
92216
92217   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92218   arg2 = (float)jarg2;
92219   arg3 = (float)jarg3;
92220   {
92221     try {
92222       result = (float)(*arg1)->Snap(arg2,arg3);
92223     } catch (std::out_of_range& e) {
92224       {
92225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92226       };
92227     } catch (std::exception& e) {
92228       {
92229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92230       };
92231     } catch (...) {
92232       {
92233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92234       };
92235     }
92236   }
92237   jresult = result;
92238   return jresult;
92239 }
92240
92241
92242 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
92243   float jresult ;
92244   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92245   float arg2 ;
92246   float result;
92247
92248   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92249   arg2 = (float)jarg2;
92250   {
92251     try {
92252       result = (float)(*arg1)->Snap(arg2);
92253     } catch (std::out_of_range& e) {
92254       {
92255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92256       };
92257     } catch (std::exception& e) {
92258       {
92259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92260       };
92261     } catch (...) {
92262       {
92263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92264       };
92265     }
92266   }
92267   jresult = result;
92268   return jresult;
92269 }
92270
92271
92272 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
92273   float jresult ;
92274   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92275   unsigned int arg2 ;
92276   unsigned int *arg3 = 0 ;
92277   bool arg4 ;
92278   float result;
92279
92280   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92281   arg2 = (unsigned int)jarg2;
92282   arg3 = (unsigned int *)jarg3;
92283   arg4 = jarg4 ? true : false;
92284   {
92285     try {
92286       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
92287     } catch (std::out_of_range& e) {
92288       {
92289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92290       };
92291     } catch (std::exception& e) {
92292       {
92293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92294       };
92295     } catch (...) {
92296       {
92297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92298       };
92299     }
92300   }
92301   jresult = result;
92302   return jresult;
92303 }
92304
92305
92306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
92307   unsigned int jresult ;
92308   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92309   float arg2 ;
92310   bool arg3 ;
92311   unsigned int result;
92312
92313   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92314   arg2 = (float)jarg2;
92315   arg3 = jarg3 ? true : false;
92316   {
92317     try {
92318       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
92319     } catch (std::out_of_range& e) {
92320       {
92321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92322       };
92323     } catch (std::exception& e) {
92324       {
92325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92326       };
92327     } catch (...) {
92328       {
92329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92330       };
92331     }
92332   }
92333   jresult = result;
92334   return jresult;
92335 }
92336
92337
92338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
92339   unsigned int jresult ;
92340   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92341   unsigned int result;
92342
92343   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92344   {
92345     try {
92346       result = (unsigned int)(*arg1)->GetTotalPages();
92347     } catch (std::out_of_range& e) {
92348       {
92349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92350       };
92351     } catch (std::exception& e) {
92352       {
92353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92354       };
92355     } catch (...) {
92356       {
92357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92358       };
92359     }
92360   }
92361   jresult = result;
92362   return jresult;
92363 }
92364
92365
92366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
92367   int jresult ;
92368   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92369   Dali::Toolkit::Ruler::RulerType result;
92370
92371   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92372   {
92373     try {
92374       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
92375     } catch (std::out_of_range& e) {
92376       {
92377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92378       };
92379     } catch (std::exception& e) {
92380       {
92381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92382       };
92383     } catch (...) {
92384       {
92385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92386       };
92387     }
92388   }
92389   jresult = (int)result;
92390   return jresult;
92391 }
92392
92393
92394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
92395   unsigned int jresult ;
92396   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92397   bool result;
92398
92399   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92400   {
92401     try {
92402       result = (bool)(*arg1)->IsEnabled();
92403     } catch (std::out_of_range& e) {
92404       {
92405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92406       };
92407     } catch (std::exception& e) {
92408       {
92409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92410       };
92411     } catch (...) {
92412       {
92413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92414       };
92415     }
92416   }
92417   jresult = result;
92418   return jresult;
92419 }
92420
92421
92422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
92423   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92424
92425   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92426   {
92427     try {
92428       (*arg1)->Enable();
92429     } catch (std::out_of_range& e) {
92430       {
92431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92432       };
92433     } catch (std::exception& e) {
92434       {
92435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92436       };
92437     } catch (...) {
92438       {
92439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92440       };
92441     }
92442   }
92443 }
92444
92445
92446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
92447   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92448
92449   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92450   {
92451     try {
92452       (*arg1)->Disable();
92453     } catch (std::out_of_range& e) {
92454       {
92455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92456       };
92457     } catch (std::exception& e) {
92458       {
92459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92460       };
92461     } catch (...) {
92462       {
92463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92464       };
92465     }
92466   }
92467 }
92468
92469
92470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
92471   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92472   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
92473   Dali::Toolkit::RulerDomain *argp2 ;
92474
92475   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92476   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
92477   if (!argp2) {
92478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
92479     return ;
92480   }
92481   arg2 = *argp2;
92482   {
92483     try {
92484       (*arg1)->SetDomain(arg2);
92485     } catch (std::out_of_range& e) {
92486       {
92487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92488       };
92489     } catch (std::exception& e) {
92490       {
92491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92492       };
92493     } catch (...) {
92494       {
92495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92496       };
92497     }
92498   }
92499 }
92500
92501
92502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
92503   void * jresult ;
92504   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92505   Dali::Toolkit::RulerDomain *result = 0 ;
92506
92507   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92508   {
92509     try {
92510       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
92511     } catch (std::out_of_range& e) {
92512       {
92513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92514       };
92515     } catch (std::exception& e) {
92516       {
92517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92518       };
92519     } catch (...) {
92520       {
92521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92522       };
92523     }
92524   }
92525   jresult = (void *)result;
92526   return jresult;
92527 }
92528
92529
92530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
92531   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92532
92533   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92534   {
92535     try {
92536       (*arg1)->DisableDomain();
92537     } catch (std::out_of_range& e) {
92538       {
92539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92540       };
92541     } catch (std::exception& e) {
92542       {
92543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92544       };
92545     } catch (...) {
92546       {
92547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92548       };
92549     }
92550   }
92551 }
92552
92553
92554 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
92555   float jresult ;
92556   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92557   float arg2 ;
92558   float arg3 ;
92559   float arg4 ;
92560   float result;
92561
92562   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92563   arg2 = (float)jarg2;
92564   arg3 = (float)jarg3;
92565   arg4 = (float)jarg4;
92566   {
92567     try {
92568       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
92569     } catch (std::out_of_range& e) {
92570       {
92571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92572       };
92573     } catch (std::exception& e) {
92574       {
92575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92576       };
92577     } catch (...) {
92578       {
92579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92580       };
92581     }
92582   }
92583   jresult = result;
92584   return jresult;
92585 }
92586
92587
92588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
92589   float jresult ;
92590   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92591   float arg2 ;
92592   float arg3 ;
92593   float result;
92594
92595   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92596   arg2 = (float)jarg2;
92597   arg3 = (float)jarg3;
92598   {
92599     try {
92600       result = (float)(*arg1)->Clamp(arg2,arg3);
92601     } catch (std::out_of_range& e) {
92602       {
92603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92604       };
92605     } catch (std::exception& e) {
92606       {
92607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92608       };
92609     } catch (...) {
92610       {
92611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92612       };
92613     }
92614   }
92615   jresult = result;
92616   return jresult;
92617 }
92618
92619
92620 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
92621   float jresult ;
92622   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92623   float arg2 ;
92624   float result;
92625
92626   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92627   arg2 = (float)jarg2;
92628   {
92629     try {
92630       result = (float)(*arg1)->Clamp(arg2);
92631     } catch (std::out_of_range& e) {
92632       {
92633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92634       };
92635     } catch (std::exception& e) {
92636       {
92637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92638       };
92639     } catch (...) {
92640       {
92641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92642       };
92643     }
92644   }
92645   jresult = result;
92646   return jresult;
92647 }
92648
92649
92650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
92651   float jresult ;
92652   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92653   float arg2 ;
92654   float arg3 ;
92655   float arg4 ;
92656   Dali::Toolkit::ClampState *arg5 = 0 ;
92657   float result;
92658
92659   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92660   arg2 = (float)jarg2;
92661   arg3 = (float)jarg3;
92662   arg4 = (float)jarg4;
92663   arg5 = (Dali::Toolkit::ClampState *)jarg5;
92664   if (!arg5) {
92665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92666     return 0;
92667   }
92668   {
92669     try {
92670       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
92671     } catch (std::out_of_range& e) {
92672       {
92673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92674       };
92675     } catch (std::exception& e) {
92676       {
92677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92678       };
92679     } catch (...) {
92680       {
92681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92682       };
92683     }
92684   }
92685   jresult = result;
92686   return jresult;
92687 }
92688
92689
92690 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
92691   float jresult ;
92692   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92693   float arg2 ;
92694   float arg3 ;
92695   float arg4 ;
92696   float arg5 ;
92697   float result;
92698
92699   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92700   arg2 = (float)jarg2;
92701   arg3 = (float)jarg3;
92702   arg4 = (float)jarg4;
92703   arg5 = (float)jarg5;
92704   {
92705     try {
92706       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
92707     } catch (std::out_of_range& e) {
92708       {
92709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92710       };
92711     } catch (std::exception& e) {
92712       {
92713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92714       };
92715     } catch (...) {
92716       {
92717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92718       };
92719     }
92720   }
92721   jresult = result;
92722   return jresult;
92723 }
92724
92725
92726 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
92727   float jresult ;
92728   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92729   float arg2 ;
92730   float arg3 ;
92731   float arg4 ;
92732   float result;
92733
92734   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92735   arg2 = (float)jarg2;
92736   arg3 = (float)jarg3;
92737   arg4 = (float)jarg4;
92738   {
92739     try {
92740       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
92741     } catch (std::out_of_range& e) {
92742       {
92743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92744       };
92745     } catch (std::exception& e) {
92746       {
92747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92748       };
92749     } catch (...) {
92750       {
92751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92752       };
92753     }
92754   }
92755   jresult = result;
92756   return jresult;
92757 }
92758
92759
92760 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
92761   float jresult ;
92762   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92763   float arg2 ;
92764   float arg3 ;
92765   float result;
92766
92767   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92768   arg2 = (float)jarg2;
92769   arg3 = (float)jarg3;
92770   {
92771     try {
92772       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
92773     } catch (std::out_of_range& e) {
92774       {
92775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92776       };
92777     } catch (std::exception& e) {
92778       {
92779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92780       };
92781     } catch (...) {
92782       {
92783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92784       };
92785     }
92786   }
92787   jresult = result;
92788   return jresult;
92789 }
92790
92791
92792 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
92793   float jresult ;
92794   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92795   float arg2 ;
92796   float result;
92797
92798   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92799   arg2 = (float)jarg2;
92800   {
92801     try {
92802       result = (float)(*arg1)->SnapAndClamp(arg2);
92803     } catch (std::out_of_range& e) {
92804       {
92805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92806       };
92807     } catch (std::exception& e) {
92808       {
92809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92810       };
92811     } catch (...) {
92812       {
92813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92814       };
92815     }
92816   }
92817   jresult = result;
92818   return jresult;
92819 }
92820
92821
92822 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
92823   float jresult ;
92824   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92825   float arg2 ;
92826   float arg3 ;
92827   float arg4 ;
92828   float arg5 ;
92829   Dali::Toolkit::ClampState *arg6 = 0 ;
92830   float result;
92831
92832   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92833   arg2 = (float)jarg2;
92834   arg3 = (float)jarg3;
92835   arg4 = (float)jarg4;
92836   arg5 = (float)jarg5;
92837   arg6 = (Dali::Toolkit::ClampState *)jarg6;
92838   if (!arg6) {
92839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92840     return 0;
92841   }
92842   {
92843     try {
92844       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
92845     } catch (std::out_of_range& e) {
92846       {
92847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92848       };
92849     } catch (std::exception& e) {
92850       {
92851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92852       };
92853     } catch (...) {
92854       {
92855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92856       };
92857     }
92858   }
92859   jresult = result;
92860   return jresult;
92861 }
92862
92863
92864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
92865   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92866
92867   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92868   {
92869     try {
92870       (*arg1)->Reference();
92871     } catch (std::out_of_range& e) {
92872       {
92873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92874       };
92875     } catch (std::exception& e) {
92876       {
92877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92878       };
92879     } catch (...) {
92880       {
92881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92882       };
92883     }
92884   }
92885 }
92886
92887
92888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
92889   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92890
92891   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92892   {
92893     try {
92894       (*arg1)->Unreference();
92895     } catch (std::out_of_range& e) {
92896       {
92897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92898       };
92899     } catch (std::exception& e) {
92900       {
92901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92902       };
92903     } catch (...) {
92904       {
92905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92906       };
92907     }
92908   }
92909 }
92910
92911
92912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
92913   int jresult ;
92914   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92915   int result;
92916
92917   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92918   {
92919     try {
92920       result = (int)(*arg1)->ReferenceCount();
92921     } catch (std::out_of_range& e) {
92922       {
92923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92924       };
92925     } catch (std::exception& e) {
92926       {
92927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92928       };
92929     } catch (...) {
92930       {
92931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92932       };
92933     }
92934   }
92935   jresult = result;
92936   return jresult;
92937 }
92938
92939
92940 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
92941     return (Dali::RefObject *)jarg1;
92942 }
92943
92944 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
92945     return (Dali::SignalObserver *)jarg1;
92946 }
92947
92948 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
92949     return (Dali::ConnectionTrackerInterface *)jarg1;
92950 }
92951
92952 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
92953     return (Dali::BaseHandle *)jarg1;
92954 }
92955
92956 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
92957     return (Dali::BaseHandle *)jarg1;
92958 }
92959
92960 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
92961     return (Dali::BaseHandle *)jarg1;
92962 }
92963
92964 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
92965     return (Dali::BaseHandle *)jarg1;
92966 }
92967
92968 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
92969     return (Dali::BaseHandle *)jarg1;
92970 }
92971
92972 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
92973     return (Dali::BaseHandle *)jarg1;
92974 }
92975
92976 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
92977     return (Dali::BaseHandle *)jarg1;
92978 }
92979
92980 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
92981     return (Dali::BaseHandle *)jarg1;
92982 }
92983
92984 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
92985     return (Dali::BaseHandle *)jarg1;
92986 }
92987
92988 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
92989     return (Dali::BaseHandle *)jarg1;
92990 }
92991
92992 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
92993     return (Dali::BaseHandle *)jarg1;
92994 }
92995
92996 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
92997     return (Dali::BaseHandle *)jarg1;
92998 }
92999
93000 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
93001     return (Dali::BaseHandle *)jarg1;
93002 }
93003
93004 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
93005     return (Dali::Handle *)jarg1;
93006 }
93007
93008 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
93009     return (Dali::Handle *)jarg1;
93010 }
93011
93012 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
93013     return (Dali::BaseHandle *)jarg1;
93014 }
93015
93016 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
93017     return (Dali::BaseHandle *)jarg1;
93018 }
93019
93020 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
93021     return (Dali::Handle *)jarg1;
93022 }
93023
93024 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
93025     return (Dali::BaseHandle *)jarg1;
93026 }
93027
93028 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
93029     return (Dali::Handle *)jarg1;
93030 }
93031
93032 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
93033     return (Dali::GestureDetector *)jarg1;
93034 }
93035
93036 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
93037     return (Dali::Gesture *)jarg1;
93038 }
93039
93040 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
93041     return (Dali::Handle *)jarg1;
93042 }
93043
93044 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
93045     return (Dali::Actor *)jarg1;
93046 }
93047
93048 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
93049     return (Dali::BaseHandle *)jarg1;
93050 }
93051
93052 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
93053     return (Dali::RefObject *)jarg1;
93054 }
93055
93056 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
93057     return (Dali::Actor *)jarg1;
93058 }
93059
93060 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
93061     return (Dali::GestureDetector *)jarg1;
93062 }
93063
93064 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
93065     return (Dali::Gesture *)jarg1;
93066 }
93067
93068 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
93069     return (Dali::GestureDetector *)jarg1;
93070 }
93071
93072 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
93073     return (Dali::Gesture *)jarg1;
93074 }
93075
93076 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
93077     return (Dali::GestureDetector *)jarg1;
93078 }
93079
93080 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
93081     return (Dali::Gesture *)jarg1;
93082 }
93083
93084 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
93085     return (Dali::BaseHandle *)jarg1;
93086 }
93087
93088 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
93089     return (Dali::Handle *)jarg1;
93090 }
93091
93092 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
93093     return (Dali::BaseHandle *)jarg1;
93094 }
93095
93096 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
93097     return (Dali::Handle *)jarg1;
93098 }
93099
93100 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
93101     return (Dali::Handle *)jarg1;
93102 }
93103
93104 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
93105     return (Dali::Image *)jarg1;
93106 }
93107
93108 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
93109     return (Dali::Image *)jarg1;
93110 }
93111
93112 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
93113     return (Dali::Image *)jarg1;
93114 }
93115
93116 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
93117     return (Dali::RefObject *)jarg1;
93118 }
93119
93120 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
93121     return (Dali::Image *)jarg1;
93122 }
93123
93124 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
93125     return (Dali::Image *)jarg1;
93126 }
93127
93128 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
93129     return (Dali::ResourceImage *)jarg1;
93130 }
93131
93132 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
93133     return (Dali::Actor *)jarg1;
93134 }
93135
93136 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
93137     return (Dali::BaseHandle *)jarg1;
93138 }
93139
93140 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
93141     return (Dali::BaseHandle *)jarg1;
93142 }
93143
93144 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
93145     return (Dali::BaseHandle *)jarg1;
93146 }
93147
93148 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
93149     return (Dali::BaseHandle *)jarg1;
93150 }
93151
93152 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
93153     return (Dali::BaseHandle *)jarg1;
93154 }
93155
93156 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
93157     return (Dali::BaseHandle *)jarg1;
93158 }
93159
93160 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
93161     return (Dali::CustomActorImpl *)jarg1;
93162 }
93163
93164 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
93165     return (Dali::CustomActor *)jarg1;
93166 }
93167
93168 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
93169     return (Dali::BaseHandle *)jarg1;
93170 }
93171
93172 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
93173     return (Dali::Toolkit::Control *)jarg1;
93174 }
93175
93176 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
93177     return (Dali::Toolkit::Control *)jarg1;
93178 }
93179
93180 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
93181     return (Dali::Toolkit::Button *)jarg1;
93182 }
93183
93184 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
93185     return (Dali::Toolkit::Button *)jarg1;
93186 }
93187
93188 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
93189     return (Dali::Toolkit::Button *)jarg1;
93190 }
93191
93192 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
93193     return (Dali::Toolkit::Control *)jarg1;
93194 }
93195
93196 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
93197     return (Dali::Toolkit::Control *)jarg1;
93198 }
93199
93200 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
93201     return (Dali::Toolkit::Control *)jarg1;
93202 }
93203
93204 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
93205     return (Dali::Toolkit::Control *)jarg1;
93206 }
93207
93208 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
93209     return (Dali::Toolkit::Control *)jarg1;
93210 }
93211
93212 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
93213     return (Dali::RefObject *)jarg1;
93214 }
93215
93216 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
93217     return (Dali::Toolkit::Scrollable *)jarg1;
93218 }
93219
93220 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
93221     return (Dali::BaseHandle *)jarg1;
93222 }
93223
93224 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
93225     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
93226 }
93227
93228 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
93229     return (Dali::RefObject *)jarg1;
93230 }
93231
93232 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
93233     return (Dali::Toolkit::Ruler *)jarg1;
93234 }
93235
93236 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
93237     return (Dali::Toolkit::Ruler *)jarg1;
93238 }
93239
93240 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
93241     return (Dali::Toolkit::Scrollable *)jarg1;
93242 }
93243
93244 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
93245     return (Dali::Toolkit::Control *)jarg1;
93246 }
93247
93248 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
93249     return (Dali::Toolkit::Control *)jarg1;
93250 }
93251
93252 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
93253     return (Dali::Toolkit::Control *)jarg1;
93254 }
93255
93256 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
93257     return (Dali::Toolkit::Control *)jarg1;
93258 }
93259
93260 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
93261     return (Dali::BaseHandle *)jarg1;
93262 }
93263
93264 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
93265     return (Dali::BaseHandle *)jarg1;
93266 }
93267
93268 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
93269     return (Dali::Toolkit::Control *)jarg1;
93270 }
93271
93272 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
93273     return (Dali::Toolkit::Control *)jarg1;
93274 }
93275
93276 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
93277     return (Dali::Toolkit::Control *)jarg1;
93278 }
93279
93280 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
93281     return (Dali::Toolkit::Control *)jarg1;
93282 }
93283
93284 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
93285     return (Dali::Toolkit::Control *)jarg1;
93286 }
93287
93288 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
93289     return (Dali::Toolkit::Control *)jarg1;
93290 }
93291
93292 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
93293     return (Dali::Toolkit::PageTurnView *)jarg1;
93294 }
93295
93296 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
93297     return (Dali::Toolkit::PageTurnView *)jarg1;
93298 }
93299
93300 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
93301     return (Dali::Toolkit::Button *)jarg1;
93302 }
93303
93304 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
93305     return (Dali::BaseHandle *)jarg1;
93306 }
93307
93308 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
93309     return (Dali::BaseHandle *)jarg1;
93310 }
93311
93312 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
93313     return (Dali::BaseHandle *)jarg1;
93314 }
93315
93316 #ifdef __cplusplus
93317 }
93318 #endif
93319