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 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 288
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427
 428 #include <dali/public-api/math/matrix.h>
 429 #include <dali/public-api/math/matrix3.h>
 430 #include <dali/public-api/math/viewport.h>
 431 #include <dali/public-api/object/property-key.h>
 432 #include <dali/devel-api/object/csharp-type-info.h>
 433 #include <dali/devel-api/object/csharp-type-registry.h>
 434
 435 #include <dali/public-api/adaptor-framework/timer.h>
 436 #include <dali/public-api/adaptor-framework/style-change.h>
 437 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 438 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 439
 440 #include <dali/devel-api/images/nine-patch-image.h>
 441
 442 #include <dali-toolkit/devel-api/builder/builder.h>
 443
 444 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 445 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 446
 447 #include <dali-toolkit/devel-api/controls/control-devel.h>
 448 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 449 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 450 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 454 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 455
 456 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 457 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 458 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 459
 460 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 461 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 463
 464 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 465
 466 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 467
 468
 469
 470 // add here SWIG version check
 471
 472 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 473 // disable Swig-dependent warnings
 474
 475 // 'identifier1' has C-linkage specified,
 476 // but returns UDT 'identifier2' which is incompatible with C
 477 #pragma warning(disable: 4190)
 478
 479 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 480 #pragma warning(disable: 4800)
 481
 482 // debug info too long etc etc
 483 #pragma warning(disable: 4786)
 484 #endif
 485
 486
 487 #include <stdexcept>
 488
 489
 490 #include <string>
 491
 492
 493 #include <vector>
 494 #include <algorithm>
 495 #include <stdexcept>
 496
 497
 498 #include <map>
 499 #include <algorithm>
 500 #include <stdexcept>
 501
 502
 503 #include <utility>
 504
 505
 506 typedef float floatp;
 507
 508 SWIGINTERN floatp *new_floatp(){
 509   return new float();
 510 }
 511 SWIGINTERN void delete_floatp(floatp *self){
 512   if (self) delete self;
 513 }
 514 SWIGINTERN void floatp_assign(floatp *self,float value){
 515   *self = value;
 516 }
 517 SWIGINTERN float floatp_value(floatp *self){
 518   return *self;
 519 }
 520 SWIGINTERN float *floatp_cast(floatp *self){
 521   return self;
 522 }
 523 SWIGINTERN floatp *floatp_frompointer(float *t){
 524   return (floatp *) t;
 525 }
 526
 527 typedef int intp;
 528
 529 SWIGINTERN intp *new_intp(){
 530   return new int();
 531 }
 532 SWIGINTERN void delete_intp(intp *self){
 533   if (self) delete self;
 534 }
 535 SWIGINTERN void intp_assign(intp *self,int value){
 536   *self = value;
 537 }
 538 SWIGINTERN int intp_value(intp *self){
 539   return *self;
 540 }
 541 SWIGINTERN int *intp_cast(intp *self){
 542   return self;
 543 }
 544 SWIGINTERN intp *intp_frompointer(int *t){
 545   return (intp *) t;
 546 }
 547
 548 typedef double doublep;
 549
 550 SWIGINTERN doublep *new_doublep(){
 551   return new double();
 552 }
 553 SWIGINTERN void delete_doublep(doublep *self){
 554   if (self) delete self;
 555 }
 556 SWIGINTERN void doublep_assign(doublep *self,double value){
 557   *self = value;
 558 }
 559 SWIGINTERN double doublep_value(doublep *self){
 560   return *self;
 561 }
 562 SWIGINTERN double *doublep_cast(doublep *self){
 563   return self;
 564 }
 565 SWIGINTERN doublep *doublep_frompointer(double *t){
 566   return (doublep *) t;
 567 }
 568
 569 typedef unsigned int uintp;
 570
 571 SWIGINTERN uintp *new_uintp(){
 572   return new unsigned int();
 573 }
 574 SWIGINTERN void delete_uintp(uintp *self){
 575   if (self) delete self;
 576 }
 577 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 578   *self = value;
 579 }
 580 SWIGINTERN unsigned int uintp_value(uintp *self){
 581   return *self;
 582 }
 583 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 584   return self;
 585 }
 586 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 587   return (uintp *) t;
 588 }
 589
 590 typedef unsigned short ushortp;
 591
 592 SWIGINTERN ushortp *new_ushortp(){
 593   return new unsigned short();
 594 }
 595 SWIGINTERN void delete_ushortp(ushortp *self){
 596   if (self) delete self;
 597 }
 598 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 599   *self = value;
 600 }
 601 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 602   return *self;
 603 }
 604 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 605   return self;
 606 }
 607 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 608   return (ushortp *) t;
 609 }
 610
 611 unsigned int int_to_uint(int x) {
 612    return (unsigned int) x;
 613 }
 614
 615
 616 using namespace Dali;
 617 using namespace Dali::Toolkit;
 618
 619 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 620
 621      // C++ code. DALi uses Handle <-> Body design pattern.
 622      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 623      // Handles in DALi can be converted into a boolean type
 624      // to check if the handle has a valid body attached to it.
 625      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 626      if( *self )
 627      {
 628        return true;
 629      }
 630      else
 631      {
 632        return false;
 633      }
 634     }
 635 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 636
 637      // C++ code. Check if two handles reference the same implemtion
 638      if( *self == rhs)
 639      {
 640        return true;
 641      }
 642      else
 643      {
 644        return false;
 645      }
 646     }
 647 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 648      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 649    }
 650 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){
 651      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 652    }
 653 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 654         std::vector< Dali::TouchPoint >* pv = 0;
 655         if (capacity >= 0) {
 656           pv = new std::vector< Dali::TouchPoint >();
 657           pv->reserve(capacity);
 658        } else {
 659           throw std::out_of_range("capacity");
 660        }
 661        return pv;
 662       }
 663 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 664         if (index>=0 && index<(int)self->size())
 665           return (*self)[index];
 666         else
 667           throw std::out_of_range("index");
 668       }
 669 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 670         if (index>=0 && index<(int)self->size())
 671           return (*self)[index];
 672         else
 673           throw std::out_of_range("index");
 674       }
 675 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 676         if (index>=0 && index<(int)self->size())
 677           (*self)[index] = val;
 678         else
 679           throw std::out_of_range("index");
 680       }
 681 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 682         self->insert(self->end(), values.begin(), values.end());
 683       }
 684 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 685         if (index < 0)
 686           throw std::out_of_range("index");
 687         if (count < 0)
 688           throw std::out_of_range("count");
 689         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 690           throw std::invalid_argument("invalid range");
 691         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 692       }
 693 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 694         if (index>=0 && index<(int)self->size()+1)
 695           self->insert(self->begin()+index, x);
 696         else
 697           throw std::out_of_range("index");
 698       }
 699 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 700         if (index>=0 && index<(int)self->size()+1)
 701           self->insert(self->begin()+index, values.begin(), values.end());
 702         else
 703           throw std::out_of_range("index");
 704       }
 705 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 706         if (index>=0 && index<(int)self->size())
 707           self->erase(self->begin() + index);
 708         else
 709           throw std::out_of_range("index");
 710       }
 711 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 712         if (index < 0)
 713           throw std::out_of_range("index");
 714         if (count < 0)
 715           throw std::out_of_range("count");
 716         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 717           throw std::invalid_argument("invalid range");
 718         self->erase(self->begin()+index, self->begin()+index+count);
 719       }
 720 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 721         if (count < 0)
 722           throw std::out_of_range("count");
 723         return new std::vector< Dali::TouchPoint >(count, value);
 724       }
 725 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 726         std::reverse(self->begin(), self->end());
 727       }
 728 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 729         if (index < 0)
 730           throw std::out_of_range("index");
 731         if (count < 0)
 732           throw std::out_of_range("count");
 733         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 734           throw std::invalid_argument("invalid range");
 735         std::reverse(self->begin()+index, self->begin()+index+count);
 736       }
 737 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 738         if (index < 0)
 739           throw std::out_of_range("index");
 740         if (index+values.size() > self->size())
 741           throw std::out_of_range("index");
 742         std::copy(values.begin(), values.end(), self->begin()+index);
 743       }
 744 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 745          return self->Empty();
 746       }
 747 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 748         return self->GetConnectionCount();
 749       }
 750 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 751           self->Connect( func );
 752       }
 753 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 754           self->Disconnect( func );
 755       }
 756 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 757           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 758 /*@SWIG@*/ self->Emit( arg );
 759       }
 760 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 761          return self->Empty();
 762       }
 763 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 764         return self->GetConnectionCount();
 765       }
 766 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 767           self->Connect( func );
 768       }
 769 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 770           self->Disconnect( func );
 771       }
 772 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 773           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 774 /*@SWIG@*/ self->Emit( arg );
 775       }
 776 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 777          return self->Empty();
 778       }
 779 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){
 780         return self->GetConnectionCount();
 781       }
 782 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 *)){
 783           self->Connect( func );
 784       }
 785 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 *)){
 786           self->Disconnect( func );
 787       }
 788 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){
 789           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 790 /*@SWIG@*/ self->Emit( arg );
 791       }
 792 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 793          return self->Empty();
 794       }
 795 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 796         return self->GetConnectionCount();
 797       }
 798 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 799           self->Connect( func );
 800       }
 801 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 802           self->Disconnect( func );
 803       }
 804 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 805           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 806 /*@SWIG@*/ self->Emit( arg );
 807       }
 808 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 809          return self->Empty();
 810       }
 811 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 812         return self->GetConnectionCount();
 813       }
 814 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 815           self->Connect( func );
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 818           self->Disconnect( func );
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 821           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 822 /*@SWIG@*/ self->Emit( arg );
 823       }
 824 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){
 825          return self->Empty();
 826       }
 827 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){
 828         return self->GetConnectionCount();
 829       }
 830 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 &)){
 831         self->Connect( func );
 832       }
 833 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 &)){
 834         self->Disconnect( func );
 835       }
 836 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){
 837         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 838 /*@SWIG@*/ self->Emit( arg1, arg2 );
 839       }
 840 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){
 841          return self->Empty();
 842       }
 843 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){
 844         return self->GetConnectionCount();
 845       }
 846 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 &)){
 847         self->Connect( func );
 848       }
 849 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 &)){
 850         self->Disconnect( func );
 851       }
 852 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){
 853         return self->Emit( arg1, arg2 );
 854       }
 855 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){
 856          return self->Empty();
 857       }
 858 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){
 859         return self->GetConnectionCount();
 860       }
 861 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 &)){
 862         self->Connect( func );
 863       }
 864 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 &)){
 865         self->Disconnect( func );
 866       }
 867 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){
 868         return self->Emit( arg1, arg2 );
 869       }
 870 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){
 871          return self->Empty();
 872       }
 873 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){
 874         return self->GetConnectionCount();
 875       }
 876 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 &)){
 877         self->Connect( func );
 878       }
 879 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 &)){
 880         self->Disconnect( func );
 881       }
 882 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){
 883         return self->Emit( arg1, arg2 );
 884       }
 885 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 886          return self->Empty();
 887       }
 888 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 889         return self->GetConnectionCount();
 890       }
 891 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 892           self->Connect( func );
 893       }
 894 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 895           self->Disconnect( func );
 896       }
 897 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 898           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 899 /*@SWIG@*/ self->Emit( arg );
 900       }
 901 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 902          return self->Empty();
 903       }
 904 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){
 905         return self->GetConnectionCount();
 906       }
 907 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 &)){
 908           self->Connect( func );
 909       }
 910 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 &)){
 911           self->Disconnect( func );
 912       }
 913 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){
 914           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 915 /*@SWIG@*/ self->Emit( arg );
 916       }
 917 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 918          return self->Empty();
 919       }
 920 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){
 921         return self->GetConnectionCount();
 922       }
 923 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 &)){
 924           self->Connect( func );
 925       }
 926 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 &)){
 927           self->Disconnect( func );
 928       }
 929 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){
 930           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 931 /*@SWIG@*/ self->Emit( arg );
 932       }
 933 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 934          return self->Empty();
 935       }
 936 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){
 937         return self->GetConnectionCount();
 938       }
 939 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 &)){
 940           self->Connect( func );
 941       }
 942 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 &)){
 943           self->Disconnect( func );
 944       }
 945 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){
 946           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 947 /*@SWIG@*/ self->Emit( arg );
 948       }
 949 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){
 950          return self->Empty();
 951       }
 952 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){
 953         return self->GetConnectionCount();
 954       }
 955 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 &)){
 956         self->Connect( func );
 957       }
 958 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 &)){
 959         self->Disconnect( func );
 960       }
 961 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){
 962         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 963 /*@SWIG@*/ self->Emit( arg1, arg2 );
 964       }
 965 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){
 966          return self->Empty();
 967       }
 968 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){
 969         return self->GetConnectionCount();
 970       }
 971 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 &)){
 972         self->Connect( func );
 973       }
 974 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 &)){
 975         self->Disconnect( func );
 976       }
 977 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){
 978         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 979 /*@SWIG@*/ self->Emit( arg1, arg2 );
 980       }
 981 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){
 982          return self->Empty();
 983       }
 984 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){
 985         return self->GetConnectionCount();
 986       }
 987 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 &)){
 988         self->Connect( func );
 989       }
 990 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 &)){
 991         self->Disconnect( func );
 992       }
 993 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){
 994         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 995 /*@SWIG@*/ self->Emit( arg1, arg2 );
 996       }
 997 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
 998          return self->Empty();
 999       }
1000 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1001         return self->GetConnectionCount();
1002       }
1003 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1004           self->Connect( func );
1005       }
1006 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1007           self->Disconnect( func );
1008       }
1009 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1010           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1011 /*@SWIG@*/ self->Emit( arg );
1012       }
1013 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1014          return self->Empty();
1015       }
1016 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1017         return self->GetConnectionCount();
1018       }
1019 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1020           return self->Connect( func );
1021       }
1022 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1023           self->Disconnect( func );
1024       }
1025 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1026           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1027 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1028       }
1029
1030 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1031          return self->Empty();
1032       }
1033 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1034         return self->GetConnectionCount();
1035       }
1036 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1037           self->Connect( func );
1038       }
1039 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1040           self->Disconnect( func );
1041       }
1042 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1043           return self->Emit();
1044       }
1045
1046 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1047         std::vector< unsigned int >* pv = 0;
1048         if (capacity >= 0) {
1049           pv = new std::vector< unsigned int >();
1050           pv->reserve(capacity);
1051        } else {
1052           throw std::out_of_range("capacity");
1053        }
1054        return pv;
1055       }
1056 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1057         if (index>=0 && index<(int)self->size())
1058           return (*self)[index];
1059         else
1060           throw std::out_of_range("index");
1061       }
1062 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1063         if (index>=0 && index<(int)self->size())
1064           return (*self)[index];
1065         else
1066           throw std::out_of_range("index");
1067       }
1068 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1069         if (index>=0 && index<(int)self->size())
1070           (*self)[index] = val;
1071         else
1072           throw std::out_of_range("index");
1073       }
1074 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1075         self->insert(self->end(), values.begin(), values.end());
1076       }
1077 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1078         if (index < 0)
1079           throw std::out_of_range("index");
1080         if (count < 0)
1081           throw std::out_of_range("count");
1082         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1083           throw std::invalid_argument("invalid range");
1084         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1085       }
1086 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1087         if (index>=0 && index<(int)self->size()+1)
1088           self->insert(self->begin()+index, x);
1089         else
1090           throw std::out_of_range("index");
1091       }
1092 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1093         if (index>=0 && index<(int)self->size()+1)
1094           self->insert(self->begin()+index, values.begin(), values.end());
1095         else
1096           throw std::out_of_range("index");
1097       }
1098 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1099         if (index>=0 && index<(int)self->size())
1100           self->erase(self->begin() + index);
1101         else
1102           throw std::out_of_range("index");
1103       }
1104 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1105         if (index < 0)
1106           throw std::out_of_range("index");
1107         if (count < 0)
1108           throw std::out_of_range("count");
1109         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1110           throw std::invalid_argument("invalid range");
1111         self->erase(self->begin()+index, self->begin()+index+count);
1112       }
1113 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1114         if (count < 0)
1115           throw std::out_of_range("count");
1116         return new std::vector< unsigned int >(count, value);
1117       }
1118 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1119         std::reverse(self->begin(), self->end());
1120       }
1121 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1122         if (index < 0)
1123           throw std::out_of_range("index");
1124         if (count < 0)
1125           throw std::out_of_range("count");
1126         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1127           throw std::invalid_argument("invalid range");
1128         std::reverse(self->begin()+index, self->begin()+index+count);
1129       }
1130 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1131         if (index < 0)
1132           throw std::out_of_range("index");
1133         if (index+values.size() > self->size())
1134           throw std::out_of_range("index");
1135         std::copy(values.begin(), values.end(), self->begin()+index);
1136       }
1137 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1138         return std::find(self->begin(), self->end(), value) != self->end();
1139       }
1140 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1141         int index = -1;
1142         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1143         if (it != self->end())
1144           index = (int)(it - self->begin());
1145         return index;
1146       }
1147 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1148         int index = -1;
1149         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1150         if (rit != self->rend())
1151           index = (int)(self->rend() - 1 - rit);
1152         return index;
1153       }
1154 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1155         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1156         if (it != self->end()) {
1157           self->erase(it);
1158           return true;
1159         }
1160         return false;
1161       }
1162 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){
1163         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1164         if (capacity >= 0) {
1165           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1166           pv->reserve(capacity);
1167        } else {
1168           throw std::out_of_range("capacity");
1169        }
1170        return pv;
1171       }
1172 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){
1173         if (index>=0 && index<(int)self->size())
1174           return (*self)[index];
1175         else
1176           throw std::out_of_range("index");
1177       }
1178 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){
1179         if (index>=0 && index<(int)self->size())
1180           return (*self)[index];
1181         else
1182           throw std::out_of_range("index");
1183       }
1184 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){
1185         if (index>=0 && index<(int)self->size())
1186           (*self)[index] = val;
1187         else
1188           throw std::out_of_range("index");
1189       }
1190 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){
1191         self->insert(self->end(), values.begin(), values.end());
1192       }
1193 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){
1194         if (index < 0)
1195           throw std::out_of_range("index");
1196         if (count < 0)
1197           throw std::out_of_range("count");
1198         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1199           throw std::invalid_argument("invalid range");
1200         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1201       }
1202 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){
1203         if (index>=0 && index<(int)self->size()+1)
1204           self->insert(self->begin()+index, x);
1205         else
1206           throw std::out_of_range("index");
1207       }
1208 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){
1209         if (index>=0 && index<(int)self->size()+1)
1210           self->insert(self->begin()+index, values.begin(), values.end());
1211         else
1212           throw std::out_of_range("index");
1213       }
1214 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){
1215         if (index>=0 && index<(int)self->size())
1216           self->erase(self->begin() + index);
1217         else
1218           throw std::out_of_range("index");
1219       }
1220 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){
1221         if (index < 0)
1222           throw std::out_of_range("index");
1223         if (count < 0)
1224           throw std::out_of_range("count");
1225         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1226           throw std::invalid_argument("invalid range");
1227         self->erase(self->begin()+index, self->begin()+index+count);
1228       }
1229 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){
1230         if (count < 0)
1231           throw std::out_of_range("count");
1232         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1233       }
1234 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){
1235         std::reverse(self->begin(), self->end());
1236       }
1237 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){
1238         if (index < 0)
1239           throw std::out_of_range("index");
1240         if (count < 0)
1241           throw std::out_of_range("count");
1242         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1243           throw std::invalid_argument("invalid range");
1244         std::reverse(self->begin()+index, self->begin()+index+count);
1245       }
1246 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){
1247         if (index < 0)
1248           throw std::out_of_range("index");
1249         if (index+values.size() > self->size())
1250           throw std::out_of_range("index");
1251         std::copy(values.begin(), values.end(), self->begin()+index);
1252       }
1253 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1254         std::vector< Dali::Actor >* pv = 0;
1255         if (capacity >= 0) {
1256           pv = new std::vector< Dali::Actor >();
1257           pv->reserve(capacity);
1258        } else {
1259           throw std::out_of_range("capacity");
1260        }
1261        return pv;
1262       }
1263 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1264         if (index>=0 && index<(int)self->size())
1265           return (*self)[index];
1266         else
1267           throw std::out_of_range("index");
1268       }
1269 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1270         if (index>=0 && index<(int)self->size())
1271           return (*self)[index];
1272         else
1273           throw std::out_of_range("index");
1274       }
1275 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1276         if (index>=0 && index<(int)self->size())
1277           (*self)[index] = val;
1278         else
1279           throw std::out_of_range("index");
1280       }
1281 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1282         self->insert(self->end(), values.begin(), values.end());
1283       }
1284 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1285         if (index < 0)
1286           throw std::out_of_range("index");
1287         if (count < 0)
1288           throw std::out_of_range("count");
1289         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1290           throw std::invalid_argument("invalid range");
1291         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1292       }
1293 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1294         if (index>=0 && index<(int)self->size()+1)
1295           self->insert(self->begin()+index, x);
1296         else
1297           throw std::out_of_range("index");
1298       }
1299 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1300         if (index>=0 && index<(int)self->size()+1)
1301           self->insert(self->begin()+index, values.begin(), values.end());
1302         else
1303           throw std::out_of_range("index");
1304       }
1305 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1306         if (index>=0 && index<(int)self->size())
1307           self->erase(self->begin() + index);
1308         else
1309           throw std::out_of_range("index");
1310       }
1311 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1312         if (index < 0)
1313           throw std::out_of_range("index");
1314         if (count < 0)
1315           throw std::out_of_range("count");
1316         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1317           throw std::invalid_argument("invalid range");
1318         self->erase(self->begin()+index, self->begin()+index+count);
1319       }
1320 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1321         if (count < 0)
1322           throw std::out_of_range("count");
1323         return new std::vector< Dali::Actor >(count, value);
1324       }
1325 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1326         std::reverse(self->begin(), self->end());
1327       }
1328 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1329         if (index < 0)
1330           throw std::out_of_range("index");
1331         if (count < 0)
1332           throw std::out_of_range("count");
1333         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1334           throw std::invalid_argument("invalid range");
1335         std::reverse(self->begin()+index, self->begin()+index+count);
1336       }
1337 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1338         if (index < 0)
1339           throw std::out_of_range("index");
1340         if (index+values.size() > self->size())
1341           throw std::out_of_range("index");
1342         std::copy(values.begin(), values.end(), self->begin()+index);
1343       }
1344 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1345          return self->Empty();
1346       }
1347 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1348         return self->GetConnectionCount();
1349       }
1350 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 &)){
1351           self->Connect( func );
1352       }
1353 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 &)){
1354           self->Disconnect( func );
1355       }
1356 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){
1357           return self->Emit( arg );
1358       }
1359 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){
1360          return self->Empty();
1361       }
1362 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){
1363         return self->GetConnectionCount();
1364       }
1365 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)){
1366         self->Connect( func );
1367       }
1368 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)){
1369         self->Disconnect( func );
1370       }
1371 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){
1372         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1373 /*@SWIG@*/ self->Emit( arg1, arg2 );
1374       }
1375 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1376          return self->Empty();
1377       }
1378 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){
1379         return self->GetConnectionCount();
1380       }
1381 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)){
1382         self->Connect( func );
1383       }
1384 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)){
1385         self->Disconnect( func );
1386       }
1387 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){
1388         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1389 /*@SWIG@*/ self->Emit( arg1, arg2 );
1390       }
1391 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1392          return self->Empty();
1393       }
1394 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1395         return self->GetConnectionCount();
1396       }
1397 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)){
1398         self->Connect( func );
1399       }
1400 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)){
1401         self->Disconnect( func );
1402       }
1403 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){
1404         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1405 /*@SWIG@*/ self->Emit( arg1, arg2 );
1406       }
1407 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){
1408          return self->Empty();
1409       }
1410 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){
1411         return self->GetConnectionCount();
1412       }
1413 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)){
1414         self->Connect( func );
1415       }
1416 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)){
1417         self->Disconnect( func );
1418       }
1419 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){
1420         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1421 /*@SWIG@*/ self->Emit( arg1, arg2 );
1422       }
1423 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1424          return self->Empty();
1425       }
1426 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1427         return self->GetConnectionCount();
1428       }
1429 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)){
1430           self->Connect( func );
1431       }
1432 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)){
1433           self->Disconnect( func );
1434       }
1435 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1436           return self->Emit( arg );
1437       }
1438 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1439          return self->Empty();
1440       }
1441 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1442         return self->GetConnectionCount();
1443       }
1444 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)){
1445           self->Connect( func );
1446       }
1447 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)){
1448           self->Disconnect( func );
1449       }
1450 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1451           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1452 /*@SWIG@*/ self->Emit( arg );
1453       }
1454 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){
1455          return self->Empty();
1456       }
1457 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){
1458         return self->GetConnectionCount();
1459       }
1460 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)){
1461           return self->Connect( func );
1462       }
1463 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)){
1464           self->Disconnect( func );
1465       }
1466 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){
1467           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1468 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1469       }
1470 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1471          return self->Empty();
1472       }
1473 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1474         return self->GetConnectionCount();
1475       }
1476 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)){
1477           self->Connect( func );
1478       }
1479 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)){
1480           self->Disconnect( func );
1481       }
1482 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1483           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1484 /*@SWIG@*/ self->Emit( arg );
1485       }
1486 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){
1487          return self->Empty();
1488       }
1489 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){
1490         return self->GetConnectionCount();
1491       }
1492 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)){
1493           return self->Connect( func );
1494       }
1495 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)){
1496           self->Disconnect( func );
1497       }
1498 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){
1499           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1500 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1501       }
1502 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){
1503          return self->Empty();
1504       }
1505 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){
1506         return self->GetConnectionCount();
1507       }
1508 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 &)){
1509           self->Connect( func );
1510       }
1511 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 &)){
1512           self->Disconnect( func );
1513       }
1514 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){
1515           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1516 /*@SWIG@*/ self->Emit( arg );
1517       }
1518 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1519          return self->Empty();
1520       }
1521 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){
1522         return self->GetConnectionCount();
1523       }
1524 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 &)){
1525           self->Connect( func );
1526       }
1527 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 &)){
1528           self->Disconnect( func );
1529       }
1530 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){
1531           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1532 /*@SWIG@*/ self->Emit( arg );
1533       }
1534
1535
1536 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){
1537          return self->Empty();
1538       }
1539 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){
1540         return self->GetConnectionCount();
1541       }
1542 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 &)){
1543         self->Connect( func );
1544       }
1545 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 &)){
1546         self->Disconnect( func );
1547       }
1548 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){
1549         return self->Emit( arg1, arg2 );
1550       }
1551 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1552          return self->Empty();
1553       }
1554 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1555         return self->GetConnectionCount();
1556       }
1557 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)){
1558           self->Connect( func );
1559       }
1560 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)){
1561           self->Disconnect( func );
1562       }
1563 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1564           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1565 /*@SWIG@*/ self->Emit( arg );
1566       }
1567 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1568          return self->Empty();
1569       }
1570 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1571         return self->GetConnectionCount();
1572       }
1573 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 &)){
1574           self->Connect( func );
1575       }
1576 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 &)){
1577           self->Disconnect( func );
1578       }
1579 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){
1580           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1581 /*@SWIG@*/ self->Emit( arg );
1582       }
1583 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1584          return self->Empty();
1585       }
1586 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){
1587         return self->GetConnectionCount();
1588       }
1589 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)){
1590         self->Connect( func );
1591       }
1592 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)){
1593         self->Disconnect( func );
1594       }
1595 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){
1596         return self->Emit( arg1, arg2 );
1597       }
1598 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1599          return self->Empty();
1600       }
1601 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){
1602         return self->GetConnectionCount();
1603       }
1604 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)){
1605         self->Connect( func );
1606       }
1607 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)){
1608         self->Disconnect( func );
1609       }
1610 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){
1611         return self->Emit( arg1, arg2 );
1612       }
1613
1614
1615 /* ---------------------------------------------------
1616  * C++ director class methods
1617  * --------------------------------------------------- */
1618
1619 #include "dali_wrap.h"
1620
1621 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1622   swig_init_callbacks();
1623 }
1624
1625 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1626
1627 }
1628
1629
1630 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1631   int jdepth  ;
1632
1633   if (!swig_callbackOnStageConnection) {
1634     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1635     return;
1636   } else {
1637     jdepth = depth;
1638     swig_callbackOnStageConnection(jdepth);
1639   }
1640 }
1641
1642 void SwigDirector_ViewImpl::OnStageDisconnection() {
1643   if (!swig_callbackOnStageDisconnection) {
1644     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1645     return;
1646   } else {
1647     swig_callbackOnStageDisconnection();
1648   }
1649 }
1650
1651 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1652   void * jchild = 0 ;
1653
1654   if (!swig_callbackOnChildAdd) {
1655     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1656     return;
1657   } else {
1658     jchild = (Dali::Actor *) &child;
1659     swig_callbackOnChildAdd(jchild);
1660   }
1661 }
1662
1663 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1664   void * jchild = 0 ;
1665
1666   if (!swig_callbackOnChildRemove) {
1667     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1668     return;
1669   } else {
1670     jchild = (Dali::Actor *) &child;
1671     swig_callbackOnChildRemove(jchild);
1672   }
1673 }
1674
1675 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1676   int jindex  ;
1677   void * jpropertyValue  ;
1678
1679   if (!swig_callbackOnPropertySet) {
1680     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1681     return;
1682   } else {
1683     jindex = index;
1684     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1685     swig_callbackOnPropertySet(jindex, jpropertyValue);
1686   }
1687 }
1688
1689 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1690   void * jtargetSize = 0 ;
1691
1692   if (!swig_callbackOnSizeSet) {
1693     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1694     return;
1695   } else {
1696     jtargetSize = (Dali::Vector3 *) &targetSize;
1697     swig_callbackOnSizeSet(jtargetSize);
1698   }
1699 }
1700
1701 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1702   void * janimation = 0 ;
1703   void * jtargetSize = 0 ;
1704
1705   if (!swig_callbackOnSizeAnimation) {
1706     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1707     return;
1708   } else {
1709     janimation = (Dali::Animation *) &animation;
1710     jtargetSize = (Dali::Vector3 *) &targetSize;
1711     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1712   }
1713 }
1714
1715 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1716   bool c_result = SwigValueInit< bool >() ;
1717   unsigned int jresult = 0 ;
1718   void * jarg0 = 0 ;
1719
1720   if (!swig_callbackOnTouchEvent) {
1721     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1722   } else {
1723     jarg0 = (Dali::TouchEvent *) &event;
1724     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1725     c_result = jresult ? true : false;
1726   }
1727   return c_result;
1728 }
1729
1730 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1731   bool c_result = SwigValueInit< bool >() ;
1732   unsigned int jresult = 0 ;
1733   void * jarg0 = 0 ;
1734
1735   if (!swig_callbackOnHoverEvent) {
1736     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1737   } else {
1738     jarg0 = (Dali::HoverEvent *) &event;
1739     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1740     c_result = jresult ? true : false;
1741   }
1742   return c_result;
1743 }
1744
1745 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1746   bool c_result = SwigValueInit< bool >() ;
1747   unsigned int jresult = 0 ;
1748   void * jarg0 = 0 ;
1749
1750   if (!swig_callbackOnKeyEvent) {
1751     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1752   } else {
1753     jarg0 = (Dali::KeyEvent *) &event;
1754     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1755     c_result = jresult ? true : false;
1756   }
1757   return c_result;
1758 }
1759
1760 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1761   bool c_result = SwigValueInit< bool >() ;
1762   unsigned int jresult = 0 ;
1763   void * jarg0 = 0 ;
1764
1765   if (!swig_callbackOnWheelEvent) {
1766     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1767   } else {
1768     jarg0 = (Dali::WheelEvent *) &event;
1769     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1770     c_result = jresult ? true : false;
1771   }
1772   return c_result;
1773 }
1774
1775 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1776   void * jsize = 0 ;
1777   void * jcontainer = 0 ;
1778
1779   if (!swig_callbackOnRelayout) {
1780     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1781     return;
1782   } else {
1783     jsize = (Dali::Vector2 *) &size;
1784     jcontainer = (Dali::RelayoutContainer *) &container;
1785     swig_callbackOnRelayout(jsize, jcontainer);
1786   }
1787 }
1788
1789 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1790   int jpolicy  ;
1791   int jdimension  ;
1792
1793   if (!swig_callbackOnSetResizePolicy) {
1794     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1795     return;
1796   } else {
1797     jpolicy = (int)policy;
1798     jdimension = (int)dimension;
1799     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1800   }
1801 }
1802
1803 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1804   Dali::Vector3 c_result ;
1805   void * jresult = 0 ;
1806
1807   if (!swig_callbackGetNaturalSize) {
1808     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1809   } else {
1810     jresult = (void *) swig_callbackGetNaturalSize();
1811     if (!jresult) {
1812       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1813       return c_result;
1814     }
1815     c_result = *(Dali::Vector3 *)jresult;
1816   }
1817   return c_result;
1818 }
1819
1820 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1821   float c_result = SwigValueInit< float >() ;
1822   float jresult = 0 ;
1823   void * jchild = 0 ;
1824   int jdimension  ;
1825
1826   if (!swig_callbackCalculateChildSize) {
1827     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1828   } else {
1829     jchild = (Dali::Actor *) &child;
1830     jdimension = (int)dimension;
1831     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1832     c_result = (float)jresult;
1833   }
1834   return c_result;
1835 }
1836
1837 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1838   float c_result = SwigValueInit< float >() ;
1839   float jresult = 0 ;
1840   float jwidth  ;
1841
1842   if (!swig_callbackGetHeightForWidth) {
1843     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1844   } else {
1845     jwidth = width;
1846     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1847     c_result = (float)jresult;
1848   }
1849   return c_result;
1850 }
1851
1852 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1853   float c_result = SwigValueInit< float >() ;
1854   float jresult = 0 ;
1855   float jheight  ;
1856
1857   if (!swig_callbackGetWidthForHeight) {
1858     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1859   } else {
1860     jheight = height;
1861     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1862     c_result = (float)jresult;
1863   }
1864   return c_result;
1865 }
1866
1867 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1868   bool c_result = SwigValueInit< bool >() ;
1869   unsigned int jresult = 0 ;
1870   int jdimension  ;
1871
1872   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1873     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1874   } else {
1875     jdimension = (int)dimension;
1876     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1877     c_result = jresult ? true : false;
1878   }
1879   return c_result;
1880 }
1881
1882 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1883   int jdimension  ;
1884
1885   if (!swig_callbackOnCalculateRelayoutSize) {
1886     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1887     return;
1888   } else {
1889     jdimension = (int)dimension;
1890     swig_callbackOnCalculateRelayoutSize(jdimension);
1891   }
1892 }
1893
1894 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1895   float jsize  ;
1896   int jdimension  ;
1897
1898   if (!swig_callbackOnLayoutNegotiated) {
1899     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1900     return;
1901   } else {
1902     jsize = size;
1903     jdimension = (int)dimension;
1904     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1905   }
1906 }
1907
1908 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1909   return Dali::CustomActorImpl::GetExtension();
1910 }
1911
1912 void SwigDirector_ViewImpl::OnInitialize() {
1913   if (!swig_callbackOnInitialize) {
1914     Dali::Toolkit::Internal::Control::OnInitialize();
1915     return;
1916   } else {
1917     swig_callbackOnInitialize();
1918   }
1919 }
1920
1921 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
1922   void * jchild = 0 ;
1923
1924   if (!swig_callbackOnControlChildAdd) {
1925     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
1926     return;
1927   } else {
1928     jchild = (Dali::Actor *) &child;
1929     swig_callbackOnControlChildAdd(jchild);
1930   }
1931 }
1932
1933 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
1934   void * jchild = 0 ;
1935
1936   if (!swig_callbackOnControlChildRemove) {
1937     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
1938     return;
1939   } else {
1940     jchild = (Dali::Actor *) &child;
1941     swig_callbackOnControlChildRemove(jchild);
1942   }
1943 }
1944
1945 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
1946   void * jstyleManager  ;
1947   int jchange  ;
1948
1949   if (!swig_callbackOnStyleChange) {
1950     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
1951     return;
1952   } else {
1953     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
1954     jchange = (int)change;
1955     swig_callbackOnStyleChange(jstyleManager, jchange);
1956   }
1957 }
1958
1959 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
1960   bool c_result = SwigValueInit< bool >() ;
1961   unsigned int jresult = 0 ;
1962
1963   if (!swig_callbackOnAccessibilityActivated) {
1964     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
1965   } else {
1966     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
1967     c_result = jresult ? true : false;
1968   }
1969   return c_result;
1970 }
1971
1972 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
1973   bool c_result = SwigValueInit< bool >() ;
1974   unsigned int jresult = 0 ;
1975   void * jgesture  ;
1976
1977   if (!swig_callbackOnAccessibilityPan) {
1978     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
1979   } else {
1980     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
1981     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
1982     c_result = jresult ? true : false;
1983   }
1984   return c_result;
1985 }
1986
1987 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
1988   bool c_result = SwigValueInit< bool >() ;
1989   unsigned int jresult = 0 ;
1990   void * jtouchEvent = 0 ;
1991
1992   if (!swig_callbackOnAccessibilityTouch) {
1993     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
1994   } else {
1995     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
1996     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
1997     c_result = jresult ? true : false;
1998   }
1999   return c_result;
2000 }
2001
2002 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2003   bool c_result = SwigValueInit< bool >() ;
2004   unsigned int jresult = 0 ;
2005   unsigned int jisIncrease  ;
2006
2007   if (!swig_callbackOnAccessibilityValueChange) {
2008     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2009   } else {
2010     jisIncrease = isIncrease;
2011     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2012     c_result = jresult ? true : false;
2013   }
2014   return c_result;
2015 }
2016
2017 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2018   bool c_result = SwigValueInit< bool >() ;
2019   unsigned int jresult = 0 ;
2020
2021   if (!swig_callbackOnAccessibilityZoom) {
2022     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2023   } else {
2024     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2025     c_result = jresult ? true : false;
2026   }
2027   return c_result;
2028 }
2029
2030 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2031   if (!swig_callbackOnKeyInputFocusGained) {
2032     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2033     return;
2034   } else {
2035     swig_callbackOnKeyInputFocusGained();
2036   }
2037 }
2038
2039 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2040   if (!swig_callbackOnKeyInputFocusLost) {
2041     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2042     return;
2043   } else {
2044     swig_callbackOnKeyInputFocusLost();
2045   }
2046 }
2047
2048 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2049   Dali::Actor c_result ;
2050   void * jresult = 0 ;
2051   void * jcurrentFocusedActor  ;
2052   int jdirection  ;
2053   unsigned int jloopEnabled  ;
2054
2055   if (!swig_callbackGetNextKeyboardFocusableActor) {
2056     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2057   } else {
2058     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2059     jdirection = (int)direction;
2060     jloopEnabled = loopEnabled;
2061     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2062     if (!jresult) {
2063       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2064       return c_result;
2065     }
2066     c_result = *(Dali::Actor *)jresult;
2067   }
2068   return c_result;
2069 }
2070
2071 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2072   void * jcommitedFocusableActor  ;
2073
2074   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2075     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2076     return;
2077   } else {
2078     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2079     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2080   }
2081 }
2082
2083 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2084   bool c_result = SwigValueInit< bool >() ;
2085   unsigned int jresult = 0 ;
2086
2087   if (!swig_callbackOnKeyboardEnter) {
2088     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2089   } else {
2090     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2091     c_result = jresult ? true : false;
2092   }
2093   return c_result;
2094 }
2095
2096 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2097   void * jpinch = 0 ;
2098
2099   if (!swig_callbackOnPinch) {
2100     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2101     return;
2102   } else {
2103     jpinch = (Dali::PinchGesture *) &pinch;
2104     swig_callbackOnPinch(jpinch);
2105   }
2106 }
2107
2108 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2109   void * jpan = 0 ;
2110
2111   if (!swig_callbackOnPan) {
2112     Dali::Toolkit::Internal::Control::OnPan(pan);
2113     return;
2114   } else {
2115     jpan = (Dali::PanGesture *) &pan;
2116     swig_callbackOnPan(jpan);
2117   }
2118 }
2119
2120 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2121   void * jtap = 0 ;
2122
2123   if (!swig_callbackOnTap) {
2124     Dali::Toolkit::Internal::Control::OnTap(tap);
2125     return;
2126   } else {
2127     jtap = (Dali::TapGesture *) &tap;
2128     swig_callbackOnTap(jtap);
2129   }
2130 }
2131
2132 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2133   void * jlongPress = 0 ;
2134
2135   if (!swig_callbackOnLongPress) {
2136     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2137     return;
2138   } else {
2139     jlongPress = (Dali::LongPressGesture *) &longPress;
2140     swig_callbackOnLongPress(jlongPress);
2141   }
2142 }
2143
2144 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2145   void * jslotObserver = 0 ;
2146   void * jcallback = 0 ;
2147
2148   if (!swig_callbackSignalConnected) {
2149     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2150     return;
2151   } else {
2152     jslotObserver = (void *) slotObserver;
2153     jcallback = (void *) callback;
2154     swig_callbackSignalConnected(jslotObserver, jcallback);
2155   }
2156 }
2157
2158 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2159   void * jslotObserver = 0 ;
2160   void * jcallback = 0 ;
2161
2162   if (!swig_callbackSignalDisconnected) {
2163     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2164     return;
2165   } else {
2166     jslotObserver = (void *) slotObserver;
2167     jcallback = (void *) callback;
2168     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2169   }
2170 }
2171
2172 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2173   return Dali::Toolkit::Internal::Control::GetControlExtension();
2174 }
2175
2176 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) {
2177   swig_callbackOnStageConnection = callbackOnStageConnection;
2178   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2179   swig_callbackOnChildAdd = callbackOnChildAdd;
2180   swig_callbackOnChildRemove = callbackOnChildRemove;
2181   swig_callbackOnPropertySet = callbackOnPropertySet;
2182   swig_callbackOnSizeSet = callbackOnSizeSet;
2183   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2184   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2185   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2186   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2187   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2188   swig_callbackOnRelayout = callbackOnRelayout;
2189   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2190   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2191   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2192   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2193   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2194   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2195   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2196   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2197   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2198   swig_callbackOnInitialize = callbackOnInitialize;
2199   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2200   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2201   swig_callbackOnStyleChange = callbackOnStyleChange;
2202   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2203   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2204   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2205   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2206   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2207   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2208   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2209   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2210   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2211   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2212   swig_callbackOnPinch = callbackOnPinch;
2213   swig_callbackOnPan = callbackOnPan;
2214   swig_callbackOnTap = callbackOnTap;
2215   swig_callbackOnLongPress = callbackOnLongPress;
2216   swig_callbackSignalConnected = callbackSignalConnected;
2217   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2218 }
2219
2220 void SwigDirector_ViewImpl::swig_init_callbacks() {
2221   swig_callbackOnStageConnection = 0;
2222   swig_callbackOnStageDisconnection = 0;
2223   swig_callbackOnChildAdd = 0;
2224   swig_callbackOnChildRemove = 0;
2225   swig_callbackOnPropertySet = 0;
2226   swig_callbackOnSizeSet = 0;
2227   swig_callbackOnSizeAnimation = 0;
2228   swig_callbackOnTouchEvent = 0;
2229   swig_callbackOnHoverEvent = 0;
2230   swig_callbackOnKeyEvent = 0;
2231   swig_callbackOnWheelEvent = 0;
2232   swig_callbackOnRelayout = 0;
2233   swig_callbackOnSetResizePolicy = 0;
2234   swig_callbackGetNaturalSize = 0;
2235   swig_callbackCalculateChildSize = 0;
2236   swig_callbackGetHeightForWidth = 0;
2237   swig_callbackGetWidthForHeight = 0;
2238   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2239   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2240   swig_callbackOnCalculateRelayoutSize = 0;
2241   swig_callbackOnLayoutNegotiated = 0;
2242   swig_callbackOnInitialize = 0;
2243   swig_callbackOnControlChildAdd = 0;
2244   swig_callbackOnControlChildRemove = 0;
2245   swig_callbackOnStyleChange = 0;
2246   swig_callbackOnAccessibilityActivated = 0;
2247   swig_callbackOnAccessibilityPan = 0;
2248   swig_callbackOnAccessibilityTouch = 0;
2249   swig_callbackOnAccessibilityValueChange = 0;
2250   swig_callbackOnAccessibilityZoom = 0;
2251   swig_callbackOnKeyInputFocusGained = 0;
2252   swig_callbackOnKeyInputFocusLost = 0;
2253   swig_callbackGetNextKeyboardFocusableActor = 0;
2254   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2255   swig_callbackOnKeyboardEnter = 0;
2256   swig_callbackOnPinch = 0;
2257   swig_callbackOnPan = 0;
2258   swig_callbackOnTap = 0;
2259   swig_callbackOnLongPress = 0;
2260   swig_callbackSignalConnected = 0;
2261   swig_callbackSignalDisconnected = 0;
2262 }
2263
2264 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2265   swig_init_callbacks();
2266 }
2267
2268 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2269
2270 }
2271
2272
2273 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2274   unsigned int c_result = SwigValueInit< unsigned int >() ;
2275   unsigned int jresult = 0 ;
2276
2277   if (!swig_callbackGetNumberOfItems) {
2278     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2279   } else {
2280     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2281     c_result = (unsigned int)jresult;
2282   }
2283   return c_result;
2284 }
2285
2286 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2287   Dali::Actor c_result ;
2288   void * jresult = 0 ;
2289   unsigned int jitemId  ;
2290
2291   if (!swig_callbackNewItem) {
2292     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2293   } else {
2294     jitemId = itemId;
2295     jresult = (void *) swig_callbackNewItem(jitemId);
2296     if (!jresult) {
2297       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2298       return c_result;
2299     }
2300     c_result = *(Dali::Actor *)jresult;
2301   }
2302   return c_result;
2303 }
2304
2305 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2306   unsigned int jitemId  ;
2307   void * jactor  ;
2308
2309   if (!swig_callbackItemReleased) {
2310     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2311     return;
2312   } else {
2313     jitemId = itemId;
2314     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2315     swig_callbackItemReleased(jitemId, jactor);
2316   }
2317 }
2318
2319 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2320   return Dali::Toolkit::ItemFactory::GetExtension();
2321 }
2322
2323 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2324   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2325   swig_callbackNewItem = callbackNewItem;
2326   swig_callbackItemReleased = callbackItemReleased;
2327 }
2328
2329 void SwigDirector_ItemFactory::swig_init_callbacks() {
2330   swig_callbackGetNumberOfItems = 0;
2331   swig_callbackNewItem = 0;
2332   swig_callbackItemReleased = 0;
2333 }
2334
2335 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2336   swig_init_callbacks();
2337 }
2338
2339 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2340
2341 }
2342
2343
2344 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2345   Dali::Actor c_result ;
2346   void * jresult = 0 ;
2347   void * jcurrent  ;
2348   void * jproposed  ;
2349   int jdirection  ;
2350
2351   if (!swig_callbackGetNextFocusableActor) {
2352     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2353   } else {
2354     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2355     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2356     jdirection = (int)direction;
2357     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2358     if (!jresult) {
2359       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2360       return c_result;
2361     }
2362     c_result = *(Dali::Actor *)jresult;
2363   }
2364   return c_result;
2365 }
2366
2367 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2368   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2369 }
2370
2371 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2372   swig_callbackGetNextFocusableActor = 0;
2373 }
2374
2375
2376 #ifdef __cplusplus
2377 extern "C" {
2378 #endif
2379
2380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2381   void * jresult ;
2382   floatp *result = 0 ;
2383
2384   {
2385     try {
2386       result = (floatp *)new_floatp();
2387     } catch (std::out_of_range& e) {
2388       {
2389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2390       };
2391     } catch (std::exception& e) {
2392       {
2393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2394       };
2395     } catch (...) {
2396       {
2397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2398       };
2399     }
2400   }
2401   jresult = (void *)result;
2402   return jresult;
2403 }
2404
2405
2406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2407   floatp *arg1 = (floatp *) 0 ;
2408
2409   arg1 = (floatp *)jarg1;
2410   {
2411     try {
2412       delete_floatp(arg1);
2413     } catch (std::out_of_range& e) {
2414       {
2415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2416       };
2417     } catch (std::exception& e) {
2418       {
2419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2420       };
2421     } catch (...) {
2422       {
2423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2424       };
2425     }
2426   }
2427 }
2428
2429
2430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2431   floatp *arg1 = (floatp *) 0 ;
2432   float arg2 ;
2433
2434   arg1 = (floatp *)jarg1;
2435   arg2 = (float)jarg2;
2436   {
2437     try {
2438       floatp_assign(arg1,arg2);
2439     } catch (std::out_of_range& e) {
2440       {
2441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2442       };
2443     } catch (std::exception& e) {
2444       {
2445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2446       };
2447     } catch (...) {
2448       {
2449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2450       };
2451     }
2452   }
2453 }
2454
2455
2456 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2457   float jresult ;
2458   floatp *arg1 = (floatp *) 0 ;
2459   float result;
2460
2461   arg1 = (floatp *)jarg1;
2462   {
2463     try {
2464       result = (float)floatp_value(arg1);
2465     } catch (std::out_of_range& e) {
2466       {
2467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2468       };
2469     } catch (std::exception& e) {
2470       {
2471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2472       };
2473     } catch (...) {
2474       {
2475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2476       };
2477     }
2478   }
2479   jresult = result;
2480   return jresult;
2481 }
2482
2483
2484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2485   void * jresult ;
2486   floatp *arg1 = (floatp *) 0 ;
2487   float *result = 0 ;
2488
2489   arg1 = (floatp *)jarg1;
2490   {
2491     try {
2492       result = (float *)floatp_cast(arg1);
2493     } catch (std::out_of_range& e) {
2494       {
2495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2496       };
2497     } catch (std::exception& e) {
2498       {
2499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2500       };
2501     } catch (...) {
2502       {
2503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2504       };
2505     }
2506   }
2507   jresult = (void *)result;
2508   return jresult;
2509 }
2510
2511
2512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2513   void * jresult ;
2514   float *arg1 = (float *) 0 ;
2515   floatp *result = 0 ;
2516
2517   arg1 = (float *)jarg1;
2518   {
2519     try {
2520       result = (floatp *)floatp_frompointer(arg1);
2521     } catch (std::out_of_range& e) {
2522       {
2523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2524       };
2525     } catch (std::exception& e) {
2526       {
2527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2528       };
2529     } catch (...) {
2530       {
2531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2532       };
2533     }
2534   }
2535   jresult = (void *)result;
2536   return jresult;
2537 }
2538
2539
2540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2541   void * jresult ;
2542   intp *result = 0 ;
2543
2544   {
2545     try {
2546       result = (intp *)new_intp();
2547     } catch (std::out_of_range& e) {
2548       {
2549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2550       };
2551     } catch (std::exception& e) {
2552       {
2553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2554       };
2555     } catch (...) {
2556       {
2557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2558       };
2559     }
2560   }
2561   jresult = (void *)result;
2562   return jresult;
2563 }
2564
2565
2566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2567   intp *arg1 = (intp *) 0 ;
2568
2569   arg1 = (intp *)jarg1;
2570   {
2571     try {
2572       delete_intp(arg1);
2573     } catch (std::out_of_range& e) {
2574       {
2575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2576       };
2577     } catch (std::exception& e) {
2578       {
2579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2580       };
2581     } catch (...) {
2582       {
2583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2584       };
2585     }
2586   }
2587 }
2588
2589
2590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2591   intp *arg1 = (intp *) 0 ;
2592   int arg2 ;
2593
2594   arg1 = (intp *)jarg1;
2595   arg2 = (int)jarg2;
2596   {
2597     try {
2598       intp_assign(arg1,arg2);
2599     } catch (std::out_of_range& e) {
2600       {
2601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2602       };
2603     } catch (std::exception& e) {
2604       {
2605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2606       };
2607     } catch (...) {
2608       {
2609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2610       };
2611     }
2612   }
2613 }
2614
2615
2616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2617   int jresult ;
2618   intp *arg1 = (intp *) 0 ;
2619   int result;
2620
2621   arg1 = (intp *)jarg1;
2622   {
2623     try {
2624       result = (int)intp_value(arg1);
2625     } catch (std::out_of_range& e) {
2626       {
2627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2628       };
2629     } catch (std::exception& e) {
2630       {
2631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2632       };
2633     } catch (...) {
2634       {
2635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2636       };
2637     }
2638   }
2639   jresult = result;
2640   return jresult;
2641 }
2642
2643
2644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2645   void * jresult ;
2646   intp *arg1 = (intp *) 0 ;
2647   int *result = 0 ;
2648
2649   arg1 = (intp *)jarg1;
2650   {
2651     try {
2652       result = (int *)intp_cast(arg1);
2653     } catch (std::out_of_range& e) {
2654       {
2655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2656       };
2657     } catch (std::exception& e) {
2658       {
2659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2660       };
2661     } catch (...) {
2662       {
2663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2664       };
2665     }
2666   }
2667   jresult = (void *)result;
2668   return jresult;
2669 }
2670
2671
2672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2673   void * jresult ;
2674   int *arg1 = (int *) 0 ;
2675   intp *result = 0 ;
2676
2677   arg1 = (int *)jarg1;
2678   {
2679     try {
2680       result = (intp *)intp_frompointer(arg1);
2681     } catch (std::out_of_range& e) {
2682       {
2683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2684       };
2685     } catch (std::exception& e) {
2686       {
2687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2688       };
2689     } catch (...) {
2690       {
2691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2692       };
2693     }
2694   }
2695   jresult = (void *)result;
2696   return jresult;
2697 }
2698
2699
2700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2701   void * jresult ;
2702   doublep *result = 0 ;
2703
2704   {
2705     try {
2706       result = (doublep *)new_doublep();
2707     } catch (std::out_of_range& e) {
2708       {
2709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2710       };
2711     } catch (std::exception& e) {
2712       {
2713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2714       };
2715     } catch (...) {
2716       {
2717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2718       };
2719     }
2720   }
2721   jresult = (void *)result;
2722   return jresult;
2723 }
2724
2725
2726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2727   doublep *arg1 = (doublep *) 0 ;
2728
2729   arg1 = (doublep *)jarg1;
2730   {
2731     try {
2732       delete_doublep(arg1);
2733     } catch (std::out_of_range& e) {
2734       {
2735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2736       };
2737     } catch (std::exception& e) {
2738       {
2739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2740       };
2741     } catch (...) {
2742       {
2743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2744       };
2745     }
2746   }
2747 }
2748
2749
2750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2751   doublep *arg1 = (doublep *) 0 ;
2752   double arg2 ;
2753
2754   arg1 = (doublep *)jarg1;
2755   arg2 = (double)jarg2;
2756   {
2757     try {
2758       doublep_assign(arg1,arg2);
2759     } catch (std::out_of_range& e) {
2760       {
2761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2762       };
2763     } catch (std::exception& e) {
2764       {
2765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2766       };
2767     } catch (...) {
2768       {
2769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2770       };
2771     }
2772   }
2773 }
2774
2775
2776 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2777   double jresult ;
2778   doublep *arg1 = (doublep *) 0 ;
2779   double result;
2780
2781   arg1 = (doublep *)jarg1;
2782   {
2783     try {
2784       result = (double)doublep_value(arg1);
2785     } catch (std::out_of_range& e) {
2786       {
2787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2788       };
2789     } catch (std::exception& e) {
2790       {
2791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2792       };
2793     } catch (...) {
2794       {
2795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2796       };
2797     }
2798   }
2799   jresult = result;
2800   return jresult;
2801 }
2802
2803
2804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2805   void * jresult ;
2806   doublep *arg1 = (doublep *) 0 ;
2807   double *result = 0 ;
2808
2809   arg1 = (doublep *)jarg1;
2810   {
2811     try {
2812       result = (double *)doublep_cast(arg1);
2813     } catch (std::out_of_range& e) {
2814       {
2815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2816       };
2817     } catch (std::exception& e) {
2818       {
2819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2820       };
2821     } catch (...) {
2822       {
2823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2824       };
2825     }
2826   }
2827   jresult = (void *)result;
2828   return jresult;
2829 }
2830
2831
2832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2833   void * jresult ;
2834   double *arg1 = (double *) 0 ;
2835   doublep *result = 0 ;
2836
2837   arg1 = (double *)jarg1;
2838   {
2839     try {
2840       result = (doublep *)doublep_frompointer(arg1);
2841     } catch (std::out_of_range& e) {
2842       {
2843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2844       };
2845     } catch (std::exception& e) {
2846       {
2847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2848       };
2849     } catch (...) {
2850       {
2851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2852       };
2853     }
2854   }
2855   jresult = (void *)result;
2856   return jresult;
2857 }
2858
2859
2860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2861   void * jresult ;
2862   uintp *result = 0 ;
2863
2864   {
2865     try {
2866       result = (uintp *)new_uintp();
2867     } catch (std::out_of_range& e) {
2868       {
2869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2870       };
2871     } catch (std::exception& e) {
2872       {
2873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2874       };
2875     } catch (...) {
2876       {
2877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2878       };
2879     }
2880   }
2881   jresult = (void *)result;
2882   return jresult;
2883 }
2884
2885
2886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2887   uintp *arg1 = (uintp *) 0 ;
2888
2889   arg1 = (uintp *)jarg1;
2890   {
2891     try {
2892       delete_uintp(arg1);
2893     } catch (std::out_of_range& e) {
2894       {
2895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2896       };
2897     } catch (std::exception& e) {
2898       {
2899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2900       };
2901     } catch (...) {
2902       {
2903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2904       };
2905     }
2906   }
2907 }
2908
2909
2910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2911   uintp *arg1 = (uintp *) 0 ;
2912   unsigned int arg2 ;
2913
2914   arg1 = (uintp *)jarg1;
2915   arg2 = (unsigned int)jarg2;
2916   {
2917     try {
2918       uintp_assign(arg1,arg2);
2919     } catch (std::out_of_range& e) {
2920       {
2921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2922       };
2923     } catch (std::exception& e) {
2924       {
2925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2926       };
2927     } catch (...) {
2928       {
2929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2930       };
2931     }
2932   }
2933 }
2934
2935
2936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2937   unsigned int jresult ;
2938   uintp *arg1 = (uintp *) 0 ;
2939   unsigned int result;
2940
2941   arg1 = (uintp *)jarg1;
2942   {
2943     try {
2944       result = (unsigned int)uintp_value(arg1);
2945     } catch (std::out_of_range& e) {
2946       {
2947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2948       };
2949     } catch (std::exception& e) {
2950       {
2951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2952       };
2953     } catch (...) {
2954       {
2955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2956       };
2957     }
2958   }
2959   jresult = result;
2960   return jresult;
2961 }
2962
2963
2964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2965   void * jresult ;
2966   uintp *arg1 = (uintp *) 0 ;
2967   unsigned int *result = 0 ;
2968
2969   arg1 = (uintp *)jarg1;
2970   {
2971     try {
2972       result = (unsigned int *)uintp_cast(arg1);
2973     } catch (std::out_of_range& e) {
2974       {
2975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2976       };
2977     } catch (std::exception& e) {
2978       {
2979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2980       };
2981     } catch (...) {
2982       {
2983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2984       };
2985     }
2986   }
2987   jresult = (void *)result;
2988   return jresult;
2989 }
2990
2991
2992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2993   void * jresult ;
2994   unsigned int *arg1 = (unsigned int *) 0 ;
2995   uintp *result = 0 ;
2996
2997   arg1 = (unsigned int *)jarg1;
2998   {
2999     try {
3000       result = (uintp *)uintp_frompointer(arg1);
3001     } catch (std::out_of_range& e) {
3002       {
3003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3004       };
3005     } catch (std::exception& e) {
3006       {
3007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3008       };
3009     } catch (...) {
3010       {
3011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3012       };
3013     }
3014   }
3015   jresult = (void *)result;
3016   return jresult;
3017 }
3018
3019
3020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3021   void * jresult ;
3022   ushortp *result = 0 ;
3023
3024   {
3025     try {
3026       result = (ushortp *)new_ushortp();
3027     } catch (std::out_of_range& e) {
3028       {
3029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3030       };
3031     } catch (std::exception& e) {
3032       {
3033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3034       };
3035     } catch (...) {
3036       {
3037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3038       };
3039     }
3040   }
3041   jresult = (void *)result;
3042   return jresult;
3043 }
3044
3045
3046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3047   ushortp *arg1 = (ushortp *) 0 ;
3048
3049   arg1 = (ushortp *)jarg1;
3050   {
3051     try {
3052       delete_ushortp(arg1);
3053     } catch (std::out_of_range& e) {
3054       {
3055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3056       };
3057     } catch (std::exception& e) {
3058       {
3059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3060       };
3061     } catch (...) {
3062       {
3063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3064       };
3065     }
3066   }
3067 }
3068
3069
3070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3071   ushortp *arg1 = (ushortp *) 0 ;
3072   unsigned short arg2 ;
3073
3074   arg1 = (ushortp *)jarg1;
3075   arg2 = (unsigned short)jarg2;
3076   {
3077     try {
3078       ushortp_assign(arg1,arg2);
3079     } catch (std::out_of_range& e) {
3080       {
3081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3082       };
3083     } catch (std::exception& e) {
3084       {
3085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3086       };
3087     } catch (...) {
3088       {
3089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3090       };
3091     }
3092   }
3093 }
3094
3095
3096 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3097   unsigned short jresult ;
3098   ushortp *arg1 = (ushortp *) 0 ;
3099   unsigned short result;
3100
3101   arg1 = (ushortp *)jarg1;
3102   {
3103     try {
3104       result = (unsigned short)ushortp_value(arg1);
3105     } catch (std::out_of_range& e) {
3106       {
3107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3108       };
3109     } catch (std::exception& e) {
3110       {
3111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3112       };
3113     } catch (...) {
3114       {
3115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3116       };
3117     }
3118   }
3119   jresult = result;
3120   return jresult;
3121 }
3122
3123
3124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3125   void * jresult ;
3126   ushortp *arg1 = (ushortp *) 0 ;
3127   unsigned short *result = 0 ;
3128
3129   arg1 = (ushortp *)jarg1;
3130   {
3131     try {
3132       result = (unsigned short *)ushortp_cast(arg1);
3133     } catch (std::out_of_range& e) {
3134       {
3135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3136       };
3137     } catch (std::exception& e) {
3138       {
3139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3140       };
3141     } catch (...) {
3142       {
3143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3144       };
3145     }
3146   }
3147   jresult = (void *)result;
3148   return jresult;
3149 }
3150
3151
3152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3153   void * jresult ;
3154   unsigned short *arg1 = (unsigned short *) 0 ;
3155   ushortp *result = 0 ;
3156
3157   arg1 = (unsigned short *)jarg1;
3158   {
3159     try {
3160       result = (ushortp *)ushortp_frompointer(arg1);
3161     } catch (std::out_of_range& e) {
3162       {
3163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3164       };
3165     } catch (std::exception& e) {
3166       {
3167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3168       };
3169     } catch (...) {
3170       {
3171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3172       };
3173     }
3174   }
3175   jresult = (void *)result;
3176   return jresult;
3177 }
3178
3179
3180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3181   unsigned int jresult ;
3182   int arg1 ;
3183   unsigned int result;
3184
3185   arg1 = (int)jarg1;
3186   {
3187     try {
3188       result = (unsigned int)int_to_uint(arg1);
3189     } catch (std::out_of_range& e) {
3190       {
3191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3192       };
3193     } catch (std::exception& e) {
3194       {
3195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3196       };
3197     } catch (...) {
3198       {
3199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3200       };
3201     }
3202   }
3203   jresult = result;
3204   return jresult;
3205 }
3206
3207
3208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3209   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3210
3211   arg1 = (Dali::RefObject *)jarg1;
3212   {
3213     try {
3214       (arg1)->Reference();
3215     } catch (std::out_of_range& e) {
3216       {
3217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3218       };
3219     } catch (std::exception& e) {
3220       {
3221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3222       };
3223     } catch (...) {
3224       {
3225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3226       };
3227     }
3228   }
3229 }
3230
3231
3232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3233   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3234
3235   arg1 = (Dali::RefObject *)jarg1;
3236   {
3237     try {
3238       (arg1)->Unreference();
3239     } catch (std::out_of_range& e) {
3240       {
3241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3242       };
3243     } catch (std::exception& e) {
3244       {
3245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3246       };
3247     } catch (...) {
3248       {
3249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3250       };
3251     }
3252   }
3253 }
3254
3255
3256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3257   int jresult ;
3258   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3259   int result;
3260
3261   arg1 = (Dali::RefObject *)jarg1;
3262   {
3263     try {
3264       result = (int)(arg1)->ReferenceCount();
3265     } catch (std::out_of_range& e) {
3266       {
3267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3268       };
3269     } catch (std::exception& e) {
3270       {
3271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3272       };
3273     } catch (...) {
3274       {
3275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3276       };
3277     }
3278   }
3279   jresult = result;
3280   return jresult;
3281 }
3282
3283
3284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3285   void * jresult ;
3286   Dali::Any *result = 0 ;
3287
3288   {
3289     try {
3290       result = (Dali::Any *)new Dali::Any();
3291     } catch (std::out_of_range& e) {
3292       {
3293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3294       };
3295     } catch (std::exception& e) {
3296       {
3297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3298       };
3299     } catch (...) {
3300       {
3301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3302       };
3303     }
3304   }
3305   jresult = (void *)result;
3306   return jresult;
3307 }
3308
3309
3310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3311   Dali::Any *arg1 = (Dali::Any *) 0 ;
3312
3313   arg1 = (Dali::Any *)jarg1;
3314   {
3315     try {
3316       delete arg1;
3317     } catch (std::out_of_range& e) {
3318       {
3319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3320       };
3321     } catch (std::exception& e) {
3322       {
3323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3324       };
3325     } catch (...) {
3326       {
3327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3328       };
3329     }
3330   }
3331 }
3332
3333
3334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3335   char *arg1 = (char *) 0 ;
3336
3337   arg1 = (char *)jarg1;
3338   {
3339     try {
3340       Dali::Any::AssertAlways((char const *)arg1);
3341     } catch (std::out_of_range& e) {
3342       {
3343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3344       };
3345     } catch (std::exception& e) {
3346       {
3347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3348       };
3349     } catch (...) {
3350       {
3351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3352       };
3353     }
3354   }
3355 }
3356
3357
3358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3359   void * jresult ;
3360   Dali::Any *arg1 = 0 ;
3361   Dali::Any *result = 0 ;
3362
3363   arg1 = (Dali::Any *)jarg1;
3364   if (!arg1) {
3365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3366     return 0;
3367   }
3368   {
3369     try {
3370       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
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_Any_Assign(void * jarg1, void * jarg2) {
3391   void * jresult ;
3392   Dali::Any *arg1 = (Dali::Any *) 0 ;
3393   Dali::Any *arg2 = 0 ;
3394   Dali::Any *result = 0 ;
3395
3396   arg1 = (Dali::Any *)jarg1;
3397   arg2 = (Dali::Any *)jarg2;
3398   if (!arg2) {
3399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3400     return 0;
3401   }
3402   {
3403     try {
3404       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3405     } catch (std::out_of_range& e) {
3406       {
3407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3408       };
3409     } catch (std::exception& e) {
3410       {
3411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3412       };
3413     } catch (...) {
3414       {
3415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3416       };
3417     }
3418   }
3419   jresult = (void *)result;
3420   return jresult;
3421 }
3422
3423
3424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3425   void * jresult ;
3426   Dali::Any *arg1 = (Dali::Any *) 0 ;
3427   std::type_info *result = 0 ;
3428
3429   arg1 = (Dali::Any *)jarg1;
3430   {
3431     try {
3432       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3433     } catch (std::out_of_range& e) {
3434       {
3435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3436       };
3437     } catch (std::exception& e) {
3438       {
3439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3440       };
3441     } catch (...) {
3442       {
3443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3444       };
3445     }
3446   }
3447   jresult = (void *)result;
3448   return jresult;
3449 }
3450
3451
3452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3453   unsigned int jresult ;
3454   Dali::Any *arg1 = (Dali::Any *) 0 ;
3455   bool result;
3456
3457   arg1 = (Dali::Any *)jarg1;
3458   {
3459     try {
3460       result = (bool)((Dali::Any const *)arg1)->Empty();
3461     } catch (std::out_of_range& e) {
3462       {
3463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3464       };
3465     } catch (std::exception& e) {
3466       {
3467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3468       };
3469     } catch (...) {
3470       {
3471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3472       };
3473     }
3474   }
3475   jresult = result;
3476   return jresult;
3477 }
3478
3479
3480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3481   void * jresult ;
3482   std::type_info *arg1 = 0 ;
3483   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3484   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3485   Dali::Any::AnyContainerBase *result = 0 ;
3486
3487   arg1 = (std::type_info *)jarg1;
3488   if (!arg1) {
3489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3490     return 0;
3491   }
3492   arg2 = (Dali::Any::CloneFunc)jarg2;
3493   arg3 = (Dali::Any::DeleteFunc)jarg3;
3494   {
3495     try {
3496       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3497     } catch (std::out_of_range& e) {
3498       {
3499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3500       };
3501     } catch (std::exception& e) {
3502       {
3503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3504       };
3505     } catch (...) {
3506       {
3507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3508       };
3509     }
3510   }
3511   jresult = (void *)result;
3512   return jresult;
3513 }
3514
3515
3516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3517   void * jresult ;
3518   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3519   std::type_info *result = 0 ;
3520
3521   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3522   {
3523     try {
3524       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3525     } catch (std::out_of_range& e) {
3526       {
3527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3528       };
3529     } catch (std::exception& e) {
3530       {
3531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3532       };
3533     } catch (...) {
3534       {
3535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3536       };
3537     }
3538   }
3539   jresult = (void *)result;
3540   return jresult;
3541 }
3542
3543
3544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3545   void * jresult ;
3546   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3547   ::std::type_info *result = 0 ;
3548
3549   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3550   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3551   jresult = (void *)result;
3552   return jresult;
3553 }
3554
3555
3556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3557   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3558   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3559
3560   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3561   arg2 = (Dali::Any::CloneFunc)jarg2;
3562   if (arg1) (arg1)->mCloneFunc = arg2;
3563 }
3564
3565
3566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3567   void * jresult ;
3568   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3569   Dali::Any::CloneFunc result;
3570
3571   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3572   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3573   jresult = (void *)result;
3574   return jresult;
3575 }
3576
3577
3578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3579   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3580   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3581
3582   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3583   arg2 = (Dali::Any::DeleteFunc)jarg2;
3584   if (arg1) (arg1)->mDeleteFunc = arg2;
3585 }
3586
3587
3588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3589   void * jresult ;
3590   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3591   Dali::Any::DeleteFunc result;
3592
3593   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3594   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3595   jresult = (void *)result;
3596   return jresult;
3597 }
3598
3599
3600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3601   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3602
3603   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3604   {
3605     try {
3606       delete arg1;
3607     } catch (std::out_of_range& e) {
3608       {
3609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3610       };
3611     } catch (std::exception& e) {
3612       {
3613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3614       };
3615     } catch (...) {
3616       {
3617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3618       };
3619     }
3620   }
3621 }
3622
3623
3624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3625   Dali::Any *arg1 = (Dali::Any *) 0 ;
3626   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3627
3628   arg1 = (Dali::Any *)jarg1;
3629   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3630   if (arg1) (arg1)->mContainer = arg2;
3631 }
3632
3633
3634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3635   void * jresult ;
3636   Dali::Any *arg1 = (Dali::Any *) 0 ;
3637   Dali::Any::AnyContainerBase *result = 0 ;
3638
3639   arg1 = (Dali::Any *)jarg1;
3640   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3641   jresult = (void *)result;
3642   return jresult;
3643 }
3644
3645
3646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3647   char *arg1 = (char *) 0 ;
3648   char *arg2 = (char *) 0 ;
3649
3650   arg1 = (char *)jarg1;
3651   arg2 = (char *)jarg2;
3652   {
3653     try {
3654       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3655     } catch (std::out_of_range& e) {
3656       {
3657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3658       };
3659     } catch (std::exception& e) {
3660       {
3661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3662       };
3663     } catch (...) {
3664       {
3665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3666       };
3667     }
3668   }
3669 }
3670
3671
3672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3673   void * jresult ;
3674   char *arg1 = (char *) 0 ;
3675   char *arg2 = (char *) 0 ;
3676   Dali::DaliException *result = 0 ;
3677
3678   arg1 = (char *)jarg1;
3679   arg2 = (char *)jarg2;
3680   {
3681     try {
3682       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3683     } catch (std::out_of_range& e) {
3684       {
3685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3686       };
3687     } catch (std::exception& e) {
3688       {
3689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3690       };
3691     } catch (...) {
3692       {
3693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3694       };
3695     }
3696   }
3697   jresult = (void *)result;
3698   return jresult;
3699 }
3700
3701
3702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3703   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3704   char *arg2 = (char *) 0 ;
3705
3706   arg1 = (Dali::DaliException *)jarg1;
3707   arg2 = (char *)jarg2;
3708   {
3709     if (arg2) {
3710       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3711       strcpy((char *)arg1->location, (const char *)arg2);
3712     } else {
3713       arg1->location = 0;
3714     }
3715   }
3716 }
3717
3718
3719 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3720   char * jresult ;
3721   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3722   char *result = 0 ;
3723
3724   arg1 = (Dali::DaliException *)jarg1;
3725   result = (char *) ((arg1)->location);
3726   jresult = SWIG_csharp_string_callback((const char *)result);
3727   return jresult;
3728 }
3729
3730
3731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3732   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3733   char *arg2 = (char *) 0 ;
3734
3735   arg1 = (Dali::DaliException *)jarg1;
3736   arg2 = (char *)jarg2;
3737   {
3738     if (arg2) {
3739       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3740       strcpy((char *)arg1->condition, (const char *)arg2);
3741     } else {
3742       arg1->condition = 0;
3743     }
3744   }
3745 }
3746
3747
3748 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3749   char * jresult ;
3750   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3751   char *result = 0 ;
3752
3753   arg1 = (Dali::DaliException *)jarg1;
3754   result = (char *) ((arg1)->condition);
3755   jresult = SWIG_csharp_string_callback((const char *)result);
3756   return jresult;
3757 }
3758
3759
3760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3761   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3762
3763   arg1 = (Dali::DaliException *)jarg1;
3764   {
3765     try {
3766       delete arg1;
3767     } catch (std::out_of_range& e) {
3768       {
3769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3770       };
3771     } catch (std::exception& e) {
3772       {
3773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3774       };
3775     } catch (...) {
3776       {
3777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3778       };
3779     }
3780   }
3781 }
3782
3783
3784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3785   void * jresult ;
3786   Dali::Vector2 *result = 0 ;
3787
3788   {
3789     try {
3790       result = (Dali::Vector2 *)new Dali::Vector2();
3791     } catch (std::out_of_range& e) {
3792       {
3793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3794       };
3795     } catch (std::exception& e) {
3796       {
3797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3798       };
3799     } catch (...) {
3800       {
3801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3802       };
3803     }
3804   }
3805   jresult = (void *)result;
3806   return jresult;
3807 }
3808
3809
3810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3811   void * jresult ;
3812   float arg1 ;
3813   float arg2 ;
3814   Dali::Vector2 *result = 0 ;
3815
3816   arg1 = (float)jarg1;
3817   arg2 = (float)jarg2;
3818   {
3819     try {
3820       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3821     } catch (std::out_of_range& e) {
3822       {
3823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3824       };
3825     } catch (std::exception& e) {
3826       {
3827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3828       };
3829     } catch (...) {
3830       {
3831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3832       };
3833     }
3834   }
3835   jresult = (void *)result;
3836   return jresult;
3837 }
3838
3839
3840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3841   void * jresult ;
3842   float *arg1 = (float *) 0 ;
3843   Dali::Vector2 *result = 0 ;
3844
3845   arg1 = jarg1;
3846   {
3847     try {
3848       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3849     } catch (std::out_of_range& e) {
3850       {
3851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3852       };
3853     } catch (std::exception& e) {
3854       {
3855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3856       };
3857     } catch (...) {
3858       {
3859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3860       };
3861     }
3862   }
3863   jresult = (void *)result;
3864
3865
3866   return jresult;
3867 }
3868
3869
3870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3871   void * jresult ;
3872   Dali::Vector3 *arg1 = 0 ;
3873   Dali::Vector2 *result = 0 ;
3874
3875   arg1 = (Dali::Vector3 *)jarg1;
3876   if (!arg1) {
3877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3878     return 0;
3879   }
3880   {
3881     try {
3882       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3883     } catch (std::out_of_range& e) {
3884       {
3885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3886       };
3887     } catch (std::exception& e) {
3888       {
3889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3890       };
3891     } catch (...) {
3892       {
3893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3894       };
3895     }
3896   }
3897   jresult = (void *)result;
3898   return jresult;
3899 }
3900
3901
3902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3903   void * jresult ;
3904   Dali::Vector4 *arg1 = 0 ;
3905   Dali::Vector2 *result = 0 ;
3906
3907   arg1 = (Dali::Vector4 *)jarg1;
3908   if (!arg1) {
3909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3910     return 0;
3911   }
3912   {
3913     try {
3914       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3915     } catch (std::out_of_range& e) {
3916       {
3917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3918       };
3919     } catch (std::exception& e) {
3920       {
3921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3922       };
3923     } catch (...) {
3924       {
3925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3926       };
3927     }
3928   }
3929   jresult = (void *)result;
3930   return jresult;
3931 }
3932
3933
3934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3935   void * jresult ;
3936   Dali::Vector2 *result = 0 ;
3937
3938   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3939   jresult = (void *)result;
3940   return jresult;
3941 }
3942
3943
3944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3945   void * jresult ;
3946   Dali::Vector2 *result = 0 ;
3947
3948   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3949   jresult = (void *)result;
3950   return jresult;
3951 }
3952
3953
3954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3955   void * jresult ;
3956   Dali::Vector2 *result = 0 ;
3957
3958   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3959   jresult = (void *)result;
3960   return jresult;
3961 }
3962
3963
3964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3965   void * jresult ;
3966   Dali::Vector2 *result = 0 ;
3967
3968   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3969   jresult = (void *)result;
3970   return jresult;
3971 }
3972
3973
3974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3975   void * jresult ;
3976   Dali::Vector2 *result = 0 ;
3977
3978   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3979   jresult = (void *)result;
3980   return jresult;
3981 }
3982
3983
3984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
3985   void * jresult ;
3986   Dali::Vector2 *result = 0 ;
3987
3988   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3989   jresult = (void *)result;
3990   return jresult;
3991 }
3992
3993
3994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3995   void * jresult ;
3996   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3997   float *arg2 = (float *) 0 ;
3998   Dali::Vector2 *result = 0 ;
3999
4000   arg1 = (Dali::Vector2 *)jarg1;
4001   arg2 = jarg2;
4002   {
4003     try {
4004       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4005     } catch (std::out_of_range& e) {
4006       {
4007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4008       };
4009     } catch (std::exception& e) {
4010       {
4011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4012       };
4013     } catch (...) {
4014       {
4015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4016       };
4017     }
4018   }
4019   jresult = (void *)result;
4020
4021
4022   return jresult;
4023 }
4024
4025
4026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4027   void * jresult ;
4028   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4029   Dali::Vector3 *arg2 = 0 ;
4030   Dali::Vector2 *result = 0 ;
4031
4032   arg1 = (Dali::Vector2 *)jarg1;
4033   arg2 = (Dali::Vector3 *)jarg2;
4034   if (!arg2) {
4035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4036     return 0;
4037   }
4038   {
4039     try {
4040       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4041     } catch (std::out_of_range& e) {
4042       {
4043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4044       };
4045     } catch (std::exception& e) {
4046       {
4047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4048       };
4049     } catch (...) {
4050       {
4051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4052       };
4053     }
4054   }
4055   jresult = (void *)result;
4056   return jresult;
4057 }
4058
4059
4060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4061   void * jresult ;
4062   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4063   Dali::Vector4 *arg2 = 0 ;
4064   Dali::Vector2 *result = 0 ;
4065
4066   arg1 = (Dali::Vector2 *)jarg1;
4067   arg2 = (Dali::Vector4 *)jarg2;
4068   if (!arg2) {
4069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4070     return 0;
4071   }
4072   {
4073     try {
4074       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4075     } catch (std::out_of_range& e) {
4076       {
4077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4078       };
4079     } catch (std::exception& e) {
4080       {
4081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4082       };
4083     } catch (...) {
4084       {
4085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4086       };
4087     }
4088   }
4089   jresult = (void *)result;
4090   return jresult;
4091 }
4092
4093
4094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4095   void * jresult ;
4096   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4097   Dali::Vector2 *arg2 = 0 ;
4098   Dali::Vector2 result;
4099
4100   arg1 = (Dali::Vector2 *)jarg1;
4101   arg2 = (Dali::Vector2 *)jarg2;
4102   if (!arg2) {
4103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4104     return 0;
4105   }
4106   {
4107     try {
4108       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4109     } catch (std::out_of_range& e) {
4110       {
4111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4112       };
4113     } catch (std::exception& e) {
4114       {
4115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4116       };
4117     } catch (...) {
4118       {
4119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4120       };
4121     }
4122   }
4123   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4124   return jresult;
4125 }
4126
4127
4128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4129   void * jresult ;
4130   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4131   Dali::Vector2 *arg2 = 0 ;
4132   Dali::Vector2 *result = 0 ;
4133
4134   arg1 = (Dali::Vector2 *)jarg1;
4135   arg2 = (Dali::Vector2 *)jarg2;
4136   if (!arg2) {
4137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4138     return 0;
4139   }
4140   {
4141     try {
4142       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4143     } catch (std::out_of_range& e) {
4144       {
4145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4146       };
4147     } catch (std::exception& e) {
4148       {
4149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4150       };
4151     } catch (...) {
4152       {
4153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4154       };
4155     }
4156   }
4157   jresult = (void *)result;
4158   return jresult;
4159 }
4160
4161
4162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4163   void * jresult ;
4164   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4165   Dali::Vector2 *arg2 = 0 ;
4166   Dali::Vector2 result;
4167
4168   arg1 = (Dali::Vector2 *)jarg1;
4169   arg2 = (Dali::Vector2 *)jarg2;
4170   if (!arg2) {
4171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4172     return 0;
4173   }
4174   {
4175     try {
4176       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4177     } catch (std::out_of_range& e) {
4178       {
4179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4180       };
4181     } catch (std::exception& e) {
4182       {
4183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4184       };
4185     } catch (...) {
4186       {
4187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4188       };
4189     }
4190   }
4191   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4192   return jresult;
4193 }
4194
4195
4196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4197   void * jresult ;
4198   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4199   Dali::Vector2 *arg2 = 0 ;
4200   Dali::Vector2 *result = 0 ;
4201
4202   arg1 = (Dali::Vector2 *)jarg1;
4203   arg2 = (Dali::Vector2 *)jarg2;
4204   if (!arg2) {
4205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4206     return 0;
4207   }
4208   {
4209     try {
4210       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4211     } catch (std::out_of_range& e) {
4212       {
4213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4214       };
4215     } catch (std::exception& e) {
4216       {
4217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4218       };
4219     } catch (...) {
4220       {
4221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4222       };
4223     }
4224   }
4225   jresult = (void *)result;
4226   return jresult;
4227 }
4228
4229
4230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4231   void * jresult ;
4232   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4233   Dali::Vector2 *arg2 = 0 ;
4234   Dali::Vector2 result;
4235
4236   arg1 = (Dali::Vector2 *)jarg1;
4237   arg2 = (Dali::Vector2 *)jarg2;
4238   if (!arg2) {
4239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4240     return 0;
4241   }
4242   {
4243     try {
4244       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4245     } catch (std::out_of_range& e) {
4246       {
4247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4248       };
4249     } catch (std::exception& e) {
4250       {
4251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4252       };
4253     } catch (...) {
4254       {
4255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4256       };
4257     }
4258   }
4259   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4260   return jresult;
4261 }
4262
4263
4264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4265   void * jresult ;
4266   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4267   float arg2 ;
4268   Dali::Vector2 result;
4269
4270   arg1 = (Dali::Vector2 *)jarg1;
4271   arg2 = (float)jarg2;
4272   {
4273     try {
4274       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4275     } catch (std::out_of_range& e) {
4276       {
4277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4278       };
4279     } catch (std::exception& e) {
4280       {
4281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4282       };
4283     } catch (...) {
4284       {
4285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4286       };
4287     }
4288   }
4289   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4290   return jresult;
4291 }
4292
4293
4294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4295   void * jresult ;
4296   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4297   Dali::Vector2 *arg2 = 0 ;
4298   Dali::Vector2 *result = 0 ;
4299
4300   arg1 = (Dali::Vector2 *)jarg1;
4301   arg2 = (Dali::Vector2 *)jarg2;
4302   if (!arg2) {
4303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4304     return 0;
4305   }
4306   {
4307     try {
4308       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4309     } catch (std::out_of_range& e) {
4310       {
4311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4312       };
4313     } catch (std::exception& e) {
4314       {
4315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4316       };
4317     } catch (...) {
4318       {
4319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4320       };
4321     }
4322   }
4323   jresult = (void *)result;
4324   return jresult;
4325 }
4326
4327
4328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4329   void * jresult ;
4330   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4331   float arg2 ;
4332   Dali::Vector2 *result = 0 ;
4333
4334   arg1 = (Dali::Vector2 *)jarg1;
4335   arg2 = (float)jarg2;
4336   {
4337     try {
4338       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4339     } catch (std::out_of_range& e) {
4340       {
4341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4342       };
4343     } catch (std::exception& e) {
4344       {
4345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4346       };
4347     } catch (...) {
4348       {
4349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4350       };
4351     }
4352   }
4353   jresult = (void *)result;
4354   return jresult;
4355 }
4356
4357
4358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4359   void * jresult ;
4360   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4361   Dali::Vector2 *arg2 = 0 ;
4362   Dali::Vector2 result;
4363
4364   arg1 = (Dali::Vector2 *)jarg1;
4365   arg2 = (Dali::Vector2 *)jarg2;
4366   if (!arg2) {
4367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4368     return 0;
4369   }
4370   {
4371     try {
4372       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4373     } catch (std::out_of_range& e) {
4374       {
4375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4376       };
4377     } catch (std::exception& e) {
4378       {
4379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4380       };
4381     } catch (...) {
4382       {
4383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4384       };
4385     }
4386   }
4387   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4388   return jresult;
4389 }
4390
4391
4392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4393   void * jresult ;
4394   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4395   float arg2 ;
4396   Dali::Vector2 result;
4397
4398   arg1 = (Dali::Vector2 *)jarg1;
4399   arg2 = (float)jarg2;
4400   {
4401     try {
4402       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4403     } catch (std::out_of_range& e) {
4404       {
4405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4406       };
4407     } catch (std::exception& e) {
4408       {
4409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4410       };
4411     } catch (...) {
4412       {
4413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4414       };
4415     }
4416   }
4417   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4418   return jresult;
4419 }
4420
4421
4422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4423   void * jresult ;
4424   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4425   Dali::Vector2 *arg2 = 0 ;
4426   Dali::Vector2 *result = 0 ;
4427
4428   arg1 = (Dali::Vector2 *)jarg1;
4429   arg2 = (Dali::Vector2 *)jarg2;
4430   if (!arg2) {
4431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4432     return 0;
4433   }
4434   {
4435     try {
4436       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4437     } catch (std::out_of_range& e) {
4438       {
4439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4440       };
4441     } catch (std::exception& e) {
4442       {
4443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4444       };
4445     } catch (...) {
4446       {
4447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4448       };
4449     }
4450   }
4451   jresult = (void *)result;
4452   return jresult;
4453 }
4454
4455
4456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4457   void * jresult ;
4458   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4459   float arg2 ;
4460   Dali::Vector2 *result = 0 ;
4461
4462   arg1 = (Dali::Vector2 *)jarg1;
4463   arg2 = (float)jarg2;
4464   {
4465     try {
4466       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4467     } catch (std::out_of_range& e) {
4468       {
4469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4470       };
4471     } catch (std::exception& e) {
4472       {
4473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4474       };
4475     } catch (...) {
4476       {
4477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4478       };
4479     }
4480   }
4481   jresult = (void *)result;
4482   return jresult;
4483 }
4484
4485
4486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4487   void * jresult ;
4488   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4489   Dali::Vector2 result;
4490
4491   arg1 = (Dali::Vector2 *)jarg1;
4492   {
4493     try {
4494       result = ((Dali::Vector2 const *)arg1)->operator -();
4495     } catch (std::out_of_range& e) {
4496       {
4497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4498       };
4499     } catch (std::exception& e) {
4500       {
4501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4502       };
4503     } catch (...) {
4504       {
4505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4506       };
4507     }
4508   }
4509   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4510   return jresult;
4511 }
4512
4513
4514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4515   unsigned int jresult ;
4516   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4517   Dali::Vector2 *arg2 = 0 ;
4518   bool result;
4519
4520   arg1 = (Dali::Vector2 *)jarg1;
4521   arg2 = (Dali::Vector2 *)jarg2;
4522   if (!arg2) {
4523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4524     return 0;
4525   }
4526   {
4527     try {
4528       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4529     } catch (std::out_of_range& e) {
4530       {
4531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4532       };
4533     } catch (std::exception& e) {
4534       {
4535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4536       };
4537     } catch (...) {
4538       {
4539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4540       };
4541     }
4542   }
4543   jresult = result;
4544   return jresult;
4545 }
4546
4547
4548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4549   unsigned int jresult ;
4550   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4551   Dali::Vector2 *arg2 = 0 ;
4552   bool result;
4553
4554   arg1 = (Dali::Vector2 *)jarg1;
4555   arg2 = (Dali::Vector2 *)jarg2;
4556   if (!arg2) {
4557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4558     return 0;
4559   }
4560   {
4561     try {
4562       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4563     } catch (std::out_of_range& e) {
4564       {
4565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4566       };
4567     } catch (std::exception& e) {
4568       {
4569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4570       };
4571     } catch (...) {
4572       {
4573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4574       };
4575     }
4576   }
4577   jresult = result;
4578   return jresult;
4579 }
4580
4581
4582 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4583   float jresult ;
4584   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4585   unsigned int arg2 ;
4586   float *result = 0 ;
4587
4588   arg1 = (Dali::Vector2 *)jarg1;
4589   arg2 = (unsigned int)jarg2;
4590   {
4591     try {
4592       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4593     } catch (std::out_of_range& e) {
4594       {
4595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4596       };
4597     } catch (std::exception& e) {
4598       {
4599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4600       };
4601     } catch (...) {
4602       {
4603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4604       };
4605     }
4606   }
4607   jresult = *result;
4608   return jresult;
4609 }
4610
4611
4612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4613   float jresult ;
4614   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4615   float result;
4616
4617   arg1 = (Dali::Vector2 *)jarg1;
4618   {
4619     try {
4620       result = (float)((Dali::Vector2 const *)arg1)->Length();
4621     } catch (std::out_of_range& e) {
4622       {
4623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4624       };
4625     } catch (std::exception& e) {
4626       {
4627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4628       };
4629     } catch (...) {
4630       {
4631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4632       };
4633     }
4634   }
4635   jresult = result;
4636   return jresult;
4637 }
4638
4639
4640 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4641   float jresult ;
4642   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4643   float result;
4644
4645   arg1 = (Dali::Vector2 *)jarg1;
4646   {
4647     try {
4648       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4649     } catch (std::out_of_range& e) {
4650       {
4651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4652       };
4653     } catch (std::exception& e) {
4654       {
4655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4656       };
4657     } catch (...) {
4658       {
4659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4660       };
4661     }
4662   }
4663   jresult = result;
4664   return jresult;
4665 }
4666
4667
4668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4669   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4670
4671   arg1 = (Dali::Vector2 *)jarg1;
4672   {
4673     try {
4674       (arg1)->Normalize();
4675     } catch (std::out_of_range& e) {
4676       {
4677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4678       };
4679     } catch (std::exception& e) {
4680       {
4681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4682       };
4683     } catch (...) {
4684       {
4685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4686       };
4687     }
4688   }
4689 }
4690
4691
4692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4693   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4694   Dali::Vector2 *arg2 = 0 ;
4695   Dali::Vector2 *arg3 = 0 ;
4696
4697   arg1 = (Dali::Vector2 *)jarg1;
4698   arg2 = (Dali::Vector2 *)jarg2;
4699   if (!arg2) {
4700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4701     return ;
4702   }
4703   arg3 = (Dali::Vector2 *)jarg3;
4704   if (!arg3) {
4705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4706     return ;
4707   }
4708   {
4709     try {
4710       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4711     } catch (std::out_of_range& e) {
4712       {
4713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4714       };
4715     } catch (std::exception& e) {
4716       {
4717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4718       };
4719     } catch (...) {
4720       {
4721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4722       };
4723     }
4724   }
4725 }
4726
4727
4728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4729   void * jresult ;
4730   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4731   float *result = 0 ;
4732
4733   arg1 = (Dali::Vector2 *)jarg1;
4734   {
4735     try {
4736       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4737     } catch (std::out_of_range& e) {
4738       {
4739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4740       };
4741     } catch (std::exception& e) {
4742       {
4743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4744       };
4745     } catch (...) {
4746       {
4747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4748       };
4749     }
4750   }
4751   jresult = (void *)result;
4752   return jresult;
4753 }
4754
4755
4756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4757   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4758   float arg2 ;
4759
4760   arg1 = (Dali::Vector2 *)jarg1;
4761   arg2 = (float)jarg2;
4762   if (arg1) (arg1)->x = arg2;
4763 }
4764
4765
4766 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4767   float jresult ;
4768   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4769   float result;
4770
4771   arg1 = (Dali::Vector2 *)jarg1;
4772   result = (float) ((arg1)->x);
4773   jresult = result;
4774   return jresult;
4775 }
4776
4777
4778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4779   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4780   float arg2 ;
4781
4782   arg1 = (Dali::Vector2 *)jarg1;
4783   arg2 = (float)jarg2;
4784   if (arg1) (arg1)->width = arg2;
4785 }
4786
4787
4788 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4789   float jresult ;
4790   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4791   float result;
4792
4793   arg1 = (Dali::Vector2 *)jarg1;
4794   result = (float) ((arg1)->width);
4795   jresult = result;
4796   return jresult;
4797 }
4798
4799
4800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4801   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4802   float arg2 ;
4803
4804   arg1 = (Dali::Vector2 *)jarg1;
4805   arg2 = (float)jarg2;
4806   if (arg1) (arg1)->y = arg2;
4807 }
4808
4809
4810 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4811   float jresult ;
4812   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4813   float result;
4814
4815   arg1 = (Dali::Vector2 *)jarg1;
4816   result = (float) ((arg1)->y);
4817   jresult = result;
4818   return jresult;
4819 }
4820
4821
4822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4823   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4824   float arg2 ;
4825
4826   arg1 = (Dali::Vector2 *)jarg1;
4827   arg2 = (float)jarg2;
4828   if (arg1) (arg1)->height = arg2;
4829 }
4830
4831
4832 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4833   float jresult ;
4834   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4835   float result;
4836
4837   arg1 = (Dali::Vector2 *)jarg1;
4838   result = (float) ((arg1)->height);
4839   jresult = result;
4840   return jresult;
4841 }
4842
4843
4844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4845   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4846
4847   arg1 = (Dali::Vector2 *)jarg1;
4848   {
4849     try {
4850       delete arg1;
4851     } catch (std::out_of_range& e) {
4852       {
4853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4854       };
4855     } catch (std::exception& e) {
4856       {
4857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4858       };
4859     } catch (...) {
4860       {
4861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4862       };
4863     }
4864   }
4865 }
4866
4867
4868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4869   void * jresult ;
4870   Dali::Vector2 *arg1 = 0 ;
4871   Dali::Vector2 *arg2 = 0 ;
4872   Dali::Vector2 result;
4873
4874   arg1 = (Dali::Vector2 *)jarg1;
4875   if (!arg1) {
4876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4877     return 0;
4878   }
4879   arg2 = (Dali::Vector2 *)jarg2;
4880   if (!arg2) {
4881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4882     return 0;
4883   }
4884   {
4885     try {
4886       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4887     } catch (std::out_of_range& e) {
4888       {
4889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4890       };
4891     } catch (std::exception& e) {
4892       {
4893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4894       };
4895     } catch (...) {
4896       {
4897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4898       };
4899     }
4900   }
4901   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4902   return jresult;
4903 }
4904
4905
4906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4907   void * jresult ;
4908   Dali::Vector2 *arg1 = 0 ;
4909   Dali::Vector2 *arg2 = 0 ;
4910   Dali::Vector2 result;
4911
4912   arg1 = (Dali::Vector2 *)jarg1;
4913   if (!arg1) {
4914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4915     return 0;
4916   }
4917   arg2 = (Dali::Vector2 *)jarg2;
4918   if (!arg2) {
4919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4920     return 0;
4921   }
4922   {
4923     try {
4924       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4925     } catch (std::out_of_range& e) {
4926       {
4927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4928       };
4929     } catch (std::exception& e) {
4930       {
4931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4932       };
4933     } catch (...) {
4934       {
4935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4936       };
4937     }
4938   }
4939   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4940   return jresult;
4941 }
4942
4943
4944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
4945   void * jresult ;
4946   Dali::Vector2 *arg1 = 0 ;
4947   float *arg2 = 0 ;
4948   float *arg3 = 0 ;
4949   float temp2 ;
4950   float temp3 ;
4951   Dali::Vector2 result;
4952
4953   arg1 = (Dali::Vector2 *)jarg1;
4954   if (!arg1) {
4955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4956     return 0;
4957   }
4958   temp2 = (float)jarg2;
4959   arg2 = &temp2;
4960   temp3 = (float)jarg3;
4961   arg3 = &temp3;
4962   {
4963     try {
4964       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4965     } catch (std::out_of_range& e) {
4966       {
4967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4968       };
4969     } catch (std::exception& e) {
4970       {
4971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4972       };
4973     } catch (...) {
4974       {
4975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4976       };
4977     }
4978   }
4979   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4980   return jresult;
4981 }
4982
4983
4984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
4985   void * jresult ;
4986   Dali::Vector3 *result = 0 ;
4987
4988   {
4989     try {
4990       result = (Dali::Vector3 *)new Dali::Vector3();
4991     } catch (std::out_of_range& e) {
4992       {
4993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4994       };
4995     } catch (std::exception& e) {
4996       {
4997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4998       };
4999     } catch (...) {
5000       {
5001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5002       };
5003     }
5004   }
5005   jresult = (void *)result;
5006   return jresult;
5007 }
5008
5009
5010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5011   void * jresult ;
5012   float arg1 ;
5013   float arg2 ;
5014   float arg3 ;
5015   Dali::Vector3 *result = 0 ;
5016
5017   arg1 = (float)jarg1;
5018   arg2 = (float)jarg2;
5019   arg3 = (float)jarg3;
5020   {
5021     try {
5022       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5023     } catch (std::out_of_range& e) {
5024       {
5025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5026       };
5027     } catch (std::exception& e) {
5028       {
5029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5030       };
5031     } catch (...) {
5032       {
5033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5034       };
5035     }
5036   }
5037   jresult = (void *)result;
5038   return jresult;
5039 }
5040
5041
5042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5043   void * jresult ;
5044   float *arg1 = (float *) 0 ;
5045   Dali::Vector3 *result = 0 ;
5046
5047   arg1 = jarg1;
5048   {
5049     try {
5050       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5051     } catch (std::out_of_range& e) {
5052       {
5053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5054       };
5055     } catch (std::exception& e) {
5056       {
5057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5058       };
5059     } catch (...) {
5060       {
5061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5062       };
5063     }
5064   }
5065   jresult = (void *)result;
5066
5067
5068   return jresult;
5069 }
5070
5071
5072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5073   void * jresult ;
5074   Dali::Vector2 *arg1 = 0 ;
5075   Dali::Vector3 *result = 0 ;
5076
5077   arg1 = (Dali::Vector2 *)jarg1;
5078   if (!arg1) {
5079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5080     return 0;
5081   }
5082   {
5083     try {
5084       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5085     } catch (std::out_of_range& e) {
5086       {
5087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5088       };
5089     } catch (std::exception& e) {
5090       {
5091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5092       };
5093     } catch (...) {
5094       {
5095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5096       };
5097     }
5098   }
5099   jresult = (void *)result;
5100   return jresult;
5101 }
5102
5103
5104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5105   void * jresult ;
5106   Dali::Vector4 *arg1 = 0 ;
5107   Dali::Vector3 *result = 0 ;
5108
5109   arg1 = (Dali::Vector4 *)jarg1;
5110   if (!arg1) {
5111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5112     return 0;
5113   }
5114   {
5115     try {
5116       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5117     } catch (std::out_of_range& e) {
5118       {
5119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5120       };
5121     } catch (std::exception& e) {
5122       {
5123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5124       };
5125     } catch (...) {
5126       {
5127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5128       };
5129     }
5130   }
5131   jresult = (void *)result;
5132   return jresult;
5133 }
5134
5135
5136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5137   void * jresult ;
5138   Dali::Vector3 *result = 0 ;
5139
5140   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5141   jresult = (void *)result;
5142   return jresult;
5143 }
5144
5145
5146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5147   void * jresult ;
5148   Dali::Vector3 *result = 0 ;
5149
5150   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5151   jresult = (void *)result;
5152   return jresult;
5153 }
5154
5155
5156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5157   void * jresult ;
5158   Dali::Vector3 *result = 0 ;
5159
5160   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5161   jresult = (void *)result;
5162   return jresult;
5163 }
5164
5165
5166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5167   void * jresult ;
5168   Dali::Vector3 *result = 0 ;
5169
5170   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5171   jresult = (void *)result;
5172   return jresult;
5173 }
5174
5175
5176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5177   void * jresult ;
5178   Dali::Vector3 *result = 0 ;
5179
5180   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5181   jresult = (void *)result;
5182   return jresult;
5183 }
5184
5185
5186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5187   void * jresult ;
5188   Dali::Vector3 *result = 0 ;
5189
5190   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5191   jresult = (void *)result;
5192   return jresult;
5193 }
5194
5195
5196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5197   void * jresult ;
5198   Dali::Vector3 *result = 0 ;
5199
5200   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5201   jresult = (void *)result;
5202   return jresult;
5203 }
5204
5205
5206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5207   void * jresult ;
5208   Dali::Vector3 *result = 0 ;
5209
5210   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5211   jresult = (void *)result;
5212   return jresult;
5213 }
5214
5215
5216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5217   void * jresult ;
5218   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5219   float *arg2 = (float *) 0 ;
5220   Dali::Vector3 *result = 0 ;
5221
5222   arg1 = (Dali::Vector3 *)jarg1;
5223   arg2 = jarg2;
5224   {
5225     try {
5226       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5227     } catch (std::out_of_range& e) {
5228       {
5229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5230       };
5231     } catch (std::exception& e) {
5232       {
5233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5234       };
5235     } catch (...) {
5236       {
5237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5238       };
5239     }
5240   }
5241   jresult = (void *)result;
5242
5243
5244   return jresult;
5245 }
5246
5247
5248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5249   void * jresult ;
5250   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5251   Dali::Vector2 *arg2 = 0 ;
5252   Dali::Vector3 *result = 0 ;
5253
5254   arg1 = (Dali::Vector3 *)jarg1;
5255   arg2 = (Dali::Vector2 *)jarg2;
5256   if (!arg2) {
5257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5258     return 0;
5259   }
5260   {
5261     try {
5262       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5263     } catch (std::out_of_range& e) {
5264       {
5265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5266       };
5267     } catch (std::exception& e) {
5268       {
5269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5270       };
5271     } catch (...) {
5272       {
5273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5274       };
5275     }
5276   }
5277   jresult = (void *)result;
5278   return jresult;
5279 }
5280
5281
5282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5283   void * jresult ;
5284   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5285   Dali::Vector4 *arg2 = 0 ;
5286   Dali::Vector3 *result = 0 ;
5287
5288   arg1 = (Dali::Vector3 *)jarg1;
5289   arg2 = (Dali::Vector4 *)jarg2;
5290   if (!arg2) {
5291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5292     return 0;
5293   }
5294   {
5295     try {
5296       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5297     } catch (std::out_of_range& e) {
5298       {
5299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5300       };
5301     } catch (std::exception& e) {
5302       {
5303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5304       };
5305     } catch (...) {
5306       {
5307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5308       };
5309     }
5310   }
5311   jresult = (void *)result;
5312   return jresult;
5313 }
5314
5315
5316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5317   void * jresult ;
5318   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5319   Dali::Vector3 *arg2 = 0 ;
5320   Dali::Vector3 result;
5321
5322   arg1 = (Dali::Vector3 *)jarg1;
5323   arg2 = (Dali::Vector3 *)jarg2;
5324   if (!arg2) {
5325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5326     return 0;
5327   }
5328   {
5329     try {
5330       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5331     } catch (std::out_of_range& e) {
5332       {
5333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5334       };
5335     } catch (std::exception& e) {
5336       {
5337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5338       };
5339     } catch (...) {
5340       {
5341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5342       };
5343     }
5344   }
5345   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5346   return jresult;
5347 }
5348
5349
5350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5351   void * jresult ;
5352   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5353   Dali::Vector3 *arg2 = 0 ;
5354   Dali::Vector3 *result = 0 ;
5355
5356   arg1 = (Dali::Vector3 *)jarg1;
5357   arg2 = (Dali::Vector3 *)jarg2;
5358   if (!arg2) {
5359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5360     return 0;
5361   }
5362   {
5363     try {
5364       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5365     } catch (std::out_of_range& e) {
5366       {
5367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5368       };
5369     } catch (std::exception& e) {
5370       {
5371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5372       };
5373     } catch (...) {
5374       {
5375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5376       };
5377     }
5378   }
5379   jresult = (void *)result;
5380   return jresult;
5381 }
5382
5383
5384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5385   void * jresult ;
5386   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5387   Dali::Vector3 *arg2 = 0 ;
5388   Dali::Vector3 result;
5389
5390   arg1 = (Dali::Vector3 *)jarg1;
5391   arg2 = (Dali::Vector3 *)jarg2;
5392   if (!arg2) {
5393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5394     return 0;
5395   }
5396   {
5397     try {
5398       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5399     } catch (std::out_of_range& e) {
5400       {
5401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5402       };
5403     } catch (std::exception& e) {
5404       {
5405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5406       };
5407     } catch (...) {
5408       {
5409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5410       };
5411     }
5412   }
5413   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5414   return jresult;
5415 }
5416
5417
5418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5419   void * jresult ;
5420   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5421   Dali::Vector3 *arg2 = 0 ;
5422   Dali::Vector3 *result = 0 ;
5423
5424   arg1 = (Dali::Vector3 *)jarg1;
5425   arg2 = (Dali::Vector3 *)jarg2;
5426   if (!arg2) {
5427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5428     return 0;
5429   }
5430   {
5431     try {
5432       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5433     } catch (std::out_of_range& e) {
5434       {
5435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5436       };
5437     } catch (std::exception& e) {
5438       {
5439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5440       };
5441     } catch (...) {
5442       {
5443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5444       };
5445     }
5446   }
5447   jresult = (void *)result;
5448   return jresult;
5449 }
5450
5451
5452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5453   void * jresult ;
5454   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5455   Dali::Vector3 *arg2 = 0 ;
5456   Dali::Vector3 result;
5457
5458   arg1 = (Dali::Vector3 *)jarg1;
5459   arg2 = (Dali::Vector3 *)jarg2;
5460   if (!arg2) {
5461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5462     return 0;
5463   }
5464   {
5465     try {
5466       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5467     } catch (std::out_of_range& e) {
5468       {
5469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5470       };
5471     } catch (std::exception& e) {
5472       {
5473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5474       };
5475     } catch (...) {
5476       {
5477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5478       };
5479     }
5480   }
5481   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5482   return jresult;
5483 }
5484
5485
5486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5487   void * jresult ;
5488   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5489   float arg2 ;
5490   Dali::Vector3 result;
5491
5492   arg1 = (Dali::Vector3 *)jarg1;
5493   arg2 = (float)jarg2;
5494   {
5495     try {
5496       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5497     } catch (std::out_of_range& e) {
5498       {
5499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5500       };
5501     } catch (std::exception& e) {
5502       {
5503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5504       };
5505     } catch (...) {
5506       {
5507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5508       };
5509     }
5510   }
5511   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5512   return jresult;
5513 }
5514
5515
5516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5517   void * jresult ;
5518   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5519   Dali::Vector3 *arg2 = 0 ;
5520   Dali::Vector3 *result = 0 ;
5521
5522   arg1 = (Dali::Vector3 *)jarg1;
5523   arg2 = (Dali::Vector3 *)jarg2;
5524   if (!arg2) {
5525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5526     return 0;
5527   }
5528   {
5529     try {
5530       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5531     } catch (std::out_of_range& e) {
5532       {
5533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5534       };
5535     } catch (std::exception& e) {
5536       {
5537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5538       };
5539     } catch (...) {
5540       {
5541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5542       };
5543     }
5544   }
5545   jresult = (void *)result;
5546   return jresult;
5547 }
5548
5549
5550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5551   void * jresult ;
5552   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5553   float arg2 ;
5554   Dali::Vector3 *result = 0 ;
5555
5556   arg1 = (Dali::Vector3 *)jarg1;
5557   arg2 = (float)jarg2;
5558   {
5559     try {
5560       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5561     } catch (std::out_of_range& e) {
5562       {
5563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5564       };
5565     } catch (std::exception& e) {
5566       {
5567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5568       };
5569     } catch (...) {
5570       {
5571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5572       };
5573     }
5574   }
5575   jresult = (void *)result;
5576   return jresult;
5577 }
5578
5579
5580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5581   void * jresult ;
5582   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5583   Dali::Quaternion *arg2 = 0 ;
5584   Dali::Vector3 *result = 0 ;
5585
5586   arg1 = (Dali::Vector3 *)jarg1;
5587   arg2 = (Dali::Quaternion *)jarg2;
5588   if (!arg2) {
5589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5590     return 0;
5591   }
5592   {
5593     try {
5594       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5595     } catch (std::out_of_range& e) {
5596       {
5597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5598       };
5599     } catch (std::exception& e) {
5600       {
5601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5602       };
5603     } catch (...) {
5604       {
5605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5606       };
5607     }
5608   }
5609   jresult = (void *)result;
5610   return jresult;
5611 }
5612
5613
5614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5615   void * jresult ;
5616   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5617   Dali::Vector3 *arg2 = 0 ;
5618   Dali::Vector3 result;
5619
5620   arg1 = (Dali::Vector3 *)jarg1;
5621   arg2 = (Dali::Vector3 *)jarg2;
5622   if (!arg2) {
5623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5624     return 0;
5625   }
5626   {
5627     try {
5628       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5629     } catch (std::out_of_range& e) {
5630       {
5631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5632       };
5633     } catch (std::exception& e) {
5634       {
5635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5636       };
5637     } catch (...) {
5638       {
5639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5640       };
5641     }
5642   }
5643   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5644   return jresult;
5645 }
5646
5647
5648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5649   void * jresult ;
5650   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5651   float arg2 ;
5652   Dali::Vector3 result;
5653
5654   arg1 = (Dali::Vector3 *)jarg1;
5655   arg2 = (float)jarg2;
5656   {
5657     try {
5658       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5659     } catch (std::out_of_range& e) {
5660       {
5661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5662       };
5663     } catch (std::exception& e) {
5664       {
5665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5666       };
5667     } catch (...) {
5668       {
5669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5670       };
5671     }
5672   }
5673   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5674   return jresult;
5675 }
5676
5677
5678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5679   void * jresult ;
5680   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5681   Dali::Vector3 *arg2 = 0 ;
5682   Dali::Vector3 *result = 0 ;
5683
5684   arg1 = (Dali::Vector3 *)jarg1;
5685   arg2 = (Dali::Vector3 *)jarg2;
5686   if (!arg2) {
5687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5688     return 0;
5689   }
5690   {
5691     try {
5692       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5693     } catch (std::out_of_range& e) {
5694       {
5695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5696       };
5697     } catch (std::exception& e) {
5698       {
5699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5700       };
5701     } catch (...) {
5702       {
5703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5704       };
5705     }
5706   }
5707   jresult = (void *)result;
5708   return jresult;
5709 }
5710
5711
5712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5713   void * jresult ;
5714   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5715   float arg2 ;
5716   Dali::Vector3 *result = 0 ;
5717
5718   arg1 = (Dali::Vector3 *)jarg1;
5719   arg2 = (float)jarg2;
5720   {
5721     try {
5722       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5723     } catch (std::out_of_range& e) {
5724       {
5725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5726       };
5727     } catch (std::exception& e) {
5728       {
5729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5730       };
5731     } catch (...) {
5732       {
5733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5734       };
5735     }
5736   }
5737   jresult = (void *)result;
5738   return jresult;
5739 }
5740
5741
5742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5743   void * jresult ;
5744   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5745   Dali::Vector3 result;
5746
5747   arg1 = (Dali::Vector3 *)jarg1;
5748   {
5749     try {
5750       result = ((Dali::Vector3 const *)arg1)->operator -();
5751     } catch (std::out_of_range& e) {
5752       {
5753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5754       };
5755     } catch (std::exception& e) {
5756       {
5757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5758       };
5759     } catch (...) {
5760       {
5761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5762       };
5763     }
5764   }
5765   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5766   return jresult;
5767 }
5768
5769
5770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5771   unsigned int jresult ;
5772   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5773   Dali::Vector3 *arg2 = 0 ;
5774   bool result;
5775
5776   arg1 = (Dali::Vector3 *)jarg1;
5777   arg2 = (Dali::Vector3 *)jarg2;
5778   if (!arg2) {
5779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5780     return 0;
5781   }
5782   {
5783     try {
5784       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5785     } catch (std::out_of_range& e) {
5786       {
5787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5788       };
5789     } catch (std::exception& e) {
5790       {
5791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5792       };
5793     } catch (...) {
5794       {
5795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5796       };
5797     }
5798   }
5799   jresult = result;
5800   return jresult;
5801 }
5802
5803
5804 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5805   unsigned int jresult ;
5806   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5807   Dali::Vector3 *arg2 = 0 ;
5808   bool result;
5809
5810   arg1 = (Dali::Vector3 *)jarg1;
5811   arg2 = (Dali::Vector3 *)jarg2;
5812   if (!arg2) {
5813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5814     return 0;
5815   }
5816   {
5817     try {
5818       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5819     } catch (std::out_of_range& e) {
5820       {
5821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5822       };
5823     } catch (std::exception& e) {
5824       {
5825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5826       };
5827     } catch (...) {
5828       {
5829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5830       };
5831     }
5832   }
5833   jresult = result;
5834   return jresult;
5835 }
5836
5837
5838 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5839   float jresult ;
5840   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5841   unsigned int arg2 ;
5842   float *result = 0 ;
5843
5844   arg1 = (Dali::Vector3 *)jarg1;
5845   arg2 = (unsigned int)jarg2;
5846   {
5847     try {
5848       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5849     } catch (std::out_of_range& e) {
5850       {
5851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5852       };
5853     } catch (std::exception& e) {
5854       {
5855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5856       };
5857     } catch (...) {
5858       {
5859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5860       };
5861     }
5862   }
5863   jresult = *result;
5864   return jresult;
5865 }
5866
5867
5868 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5869   float jresult ;
5870   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5871   Dali::Vector3 *arg2 = 0 ;
5872   float result;
5873
5874   arg1 = (Dali::Vector3 *)jarg1;
5875   arg2 = (Dali::Vector3 *)jarg2;
5876   if (!arg2) {
5877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5878     return 0;
5879   }
5880   {
5881     try {
5882       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5883     } catch (std::out_of_range& e) {
5884       {
5885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5886       };
5887     } catch (std::exception& e) {
5888       {
5889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5890       };
5891     } catch (...) {
5892       {
5893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5894       };
5895     }
5896   }
5897   jresult = result;
5898   return jresult;
5899 }
5900
5901
5902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
5903   void * jresult ;
5904   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5905   Dali::Vector3 *arg2 = 0 ;
5906   Dali::Vector3 result;
5907
5908   arg1 = (Dali::Vector3 *)jarg1;
5909   arg2 = (Dali::Vector3 *)jarg2;
5910   if (!arg2) {
5911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5912     return 0;
5913   }
5914   {
5915     try {
5916       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
5917     } catch (std::out_of_range& e) {
5918       {
5919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5920       };
5921     } catch (std::exception& e) {
5922       {
5923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5924       };
5925     } catch (...) {
5926       {
5927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5928       };
5929     }
5930   }
5931   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5932   return jresult;
5933 }
5934
5935
5936 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
5937   float jresult ;
5938   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5939   float result;
5940
5941   arg1 = (Dali::Vector3 *)jarg1;
5942   {
5943     try {
5944       result = (float)((Dali::Vector3 const *)arg1)->Length();
5945     } catch (std::out_of_range& e) {
5946       {
5947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5948       };
5949     } catch (std::exception& e) {
5950       {
5951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5952       };
5953     } catch (...) {
5954       {
5955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5956       };
5957     }
5958   }
5959   jresult = result;
5960   return jresult;
5961 }
5962
5963
5964 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
5965   float jresult ;
5966   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5967   float result;
5968
5969   arg1 = (Dali::Vector3 *)jarg1;
5970   {
5971     try {
5972       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
5973     } catch (std::out_of_range& e) {
5974       {
5975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5976       };
5977     } catch (std::exception& e) {
5978       {
5979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5980       };
5981     } catch (...) {
5982       {
5983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5984       };
5985     }
5986   }
5987   jresult = result;
5988   return jresult;
5989 }
5990
5991
5992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
5993   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5994
5995   arg1 = (Dali::Vector3 *)jarg1;
5996   {
5997     try {
5998       (arg1)->Normalize();
5999     } catch (std::out_of_range& e) {
6000       {
6001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6002       };
6003     } catch (std::exception& e) {
6004       {
6005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6006       };
6007     } catch (...) {
6008       {
6009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6010       };
6011     }
6012   }
6013 }
6014
6015
6016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6017   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6018   Dali::Vector3 *arg2 = 0 ;
6019   Dali::Vector3 *arg3 = 0 ;
6020
6021   arg1 = (Dali::Vector3 *)jarg1;
6022   arg2 = (Dali::Vector3 *)jarg2;
6023   if (!arg2) {
6024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6025     return ;
6026   }
6027   arg3 = (Dali::Vector3 *)jarg3;
6028   if (!arg3) {
6029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6030     return ;
6031   }
6032   {
6033     try {
6034       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6035     } catch (std::out_of_range& e) {
6036       {
6037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6038       };
6039     } catch (std::exception& e) {
6040       {
6041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6042       };
6043     } catch (...) {
6044       {
6045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6046       };
6047     }
6048   }
6049 }
6050
6051
6052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6053   void * jresult ;
6054   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6055   float *result = 0 ;
6056
6057   arg1 = (Dali::Vector3 *)jarg1;
6058   {
6059     try {
6060       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6061     } catch (std::out_of_range& e) {
6062       {
6063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6064       };
6065     } catch (std::exception& e) {
6066       {
6067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6068       };
6069     } catch (...) {
6070       {
6071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6072       };
6073     }
6074   }
6075   jresult = (void *)result;
6076   return jresult;
6077 }
6078
6079
6080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6081   void * jresult ;
6082   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6083   Dali::Vector2 *result = 0 ;
6084
6085   arg1 = (Dali::Vector3 *)jarg1;
6086   {
6087     try {
6088       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6089     } catch (std::out_of_range& e) {
6090       {
6091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6092       };
6093     } catch (std::exception& e) {
6094       {
6095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6096       };
6097     } catch (...) {
6098       {
6099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6100       };
6101     }
6102   }
6103   jresult = (void *)result;
6104   return jresult;
6105 }
6106
6107
6108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6109   void * jresult ;
6110   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6111   Dali::Vector2 *result = 0 ;
6112
6113   arg1 = (Dali::Vector3 *)jarg1;
6114   {
6115     try {
6116       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6117     } catch (std::out_of_range& e) {
6118       {
6119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6120       };
6121     } catch (std::exception& e) {
6122       {
6123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6124       };
6125     } catch (...) {
6126       {
6127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6128       };
6129     }
6130   }
6131   jresult = (void *)result;
6132   return jresult;
6133 }
6134
6135
6136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6137   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6138   float arg2 ;
6139
6140   arg1 = (Dali::Vector3 *)jarg1;
6141   arg2 = (float)jarg2;
6142   if (arg1) (arg1)->x = arg2;
6143 }
6144
6145
6146 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6147   float jresult ;
6148   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6149   float result;
6150
6151   arg1 = (Dali::Vector3 *)jarg1;
6152   result = (float) ((arg1)->x);
6153   jresult = result;
6154   return jresult;
6155 }
6156
6157
6158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6159   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6160   float arg2 ;
6161
6162   arg1 = (Dali::Vector3 *)jarg1;
6163   arg2 = (float)jarg2;
6164   if (arg1) (arg1)->width = arg2;
6165 }
6166
6167
6168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6169   float jresult ;
6170   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6171   float result;
6172
6173   arg1 = (Dali::Vector3 *)jarg1;
6174   result = (float) ((arg1)->width);
6175   jresult = result;
6176   return jresult;
6177 }
6178
6179
6180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6181   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6182   float arg2 ;
6183
6184   arg1 = (Dali::Vector3 *)jarg1;
6185   arg2 = (float)jarg2;
6186   if (arg1) (arg1)->r = arg2;
6187 }
6188
6189
6190 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6191   float jresult ;
6192   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6193   float result;
6194
6195   arg1 = (Dali::Vector3 *)jarg1;
6196   result = (float) ((arg1)->r);
6197   jresult = result;
6198   return jresult;
6199 }
6200
6201
6202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6203   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6204   float arg2 ;
6205
6206   arg1 = (Dali::Vector3 *)jarg1;
6207   arg2 = (float)jarg2;
6208   if (arg1) (arg1)->y = arg2;
6209 }
6210
6211
6212 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6213   float jresult ;
6214   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6215   float result;
6216
6217   arg1 = (Dali::Vector3 *)jarg1;
6218   result = (float) ((arg1)->y);
6219   jresult = result;
6220   return jresult;
6221 }
6222
6223
6224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6225   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6226   float arg2 ;
6227
6228   arg1 = (Dali::Vector3 *)jarg1;
6229   arg2 = (float)jarg2;
6230   if (arg1) (arg1)->height = arg2;
6231 }
6232
6233
6234 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6235   float jresult ;
6236   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6237   float result;
6238
6239   arg1 = (Dali::Vector3 *)jarg1;
6240   result = (float) ((arg1)->height);
6241   jresult = result;
6242   return jresult;
6243 }
6244
6245
6246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6247   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6248   float arg2 ;
6249
6250   arg1 = (Dali::Vector3 *)jarg1;
6251   arg2 = (float)jarg2;
6252   if (arg1) (arg1)->g = arg2;
6253 }
6254
6255
6256 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6257   float jresult ;
6258   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6259   float result;
6260
6261   arg1 = (Dali::Vector3 *)jarg1;
6262   result = (float) ((arg1)->g);
6263   jresult = result;
6264   return jresult;
6265 }
6266
6267
6268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6269   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6270   float arg2 ;
6271
6272   arg1 = (Dali::Vector3 *)jarg1;
6273   arg2 = (float)jarg2;
6274   if (arg1) (arg1)->z = arg2;
6275 }
6276
6277
6278 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6279   float jresult ;
6280   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6281   float result;
6282
6283   arg1 = (Dali::Vector3 *)jarg1;
6284   result = (float) ((arg1)->z);
6285   jresult = result;
6286   return jresult;
6287 }
6288
6289
6290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6291   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6292   float arg2 ;
6293
6294   arg1 = (Dali::Vector3 *)jarg1;
6295   arg2 = (float)jarg2;
6296   if (arg1) (arg1)->depth = arg2;
6297 }
6298
6299
6300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6301   float jresult ;
6302   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6303   float result;
6304
6305   arg1 = (Dali::Vector3 *)jarg1;
6306   result = (float) ((arg1)->depth);
6307   jresult = result;
6308   return jresult;
6309 }
6310
6311
6312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6313   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6314   float arg2 ;
6315
6316   arg1 = (Dali::Vector3 *)jarg1;
6317   arg2 = (float)jarg2;
6318   if (arg1) (arg1)->b = arg2;
6319 }
6320
6321
6322 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6323   float jresult ;
6324   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6325   float result;
6326
6327   arg1 = (Dali::Vector3 *)jarg1;
6328   result = (float) ((arg1)->b);
6329   jresult = result;
6330   return jresult;
6331 }
6332
6333
6334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6335   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6336
6337   arg1 = (Dali::Vector3 *)jarg1;
6338   {
6339     try {
6340       delete arg1;
6341     } catch (std::out_of_range& e) {
6342       {
6343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6344       };
6345     } catch (std::exception& e) {
6346       {
6347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6348       };
6349     } catch (...) {
6350       {
6351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6352       };
6353     }
6354   }
6355 }
6356
6357
6358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6359   void * jresult ;
6360   Dali::Vector3 *arg1 = 0 ;
6361   Dali::Vector3 *arg2 = 0 ;
6362   Dali::Vector3 result;
6363
6364   arg1 = (Dali::Vector3 *)jarg1;
6365   if (!arg1) {
6366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6367     return 0;
6368   }
6369   arg2 = (Dali::Vector3 *)jarg2;
6370   if (!arg2) {
6371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6372     return 0;
6373   }
6374   {
6375     try {
6376       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6377     } catch (std::out_of_range& e) {
6378       {
6379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6380       };
6381     } catch (std::exception& e) {
6382       {
6383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6384       };
6385     } catch (...) {
6386       {
6387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6388       };
6389     }
6390   }
6391   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6392   return jresult;
6393 }
6394
6395
6396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6397   void * jresult ;
6398   Dali::Vector3 *arg1 = 0 ;
6399   Dali::Vector3 *arg2 = 0 ;
6400   Dali::Vector3 result;
6401
6402   arg1 = (Dali::Vector3 *)jarg1;
6403   if (!arg1) {
6404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6405     return 0;
6406   }
6407   arg2 = (Dali::Vector3 *)jarg2;
6408   if (!arg2) {
6409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6410     return 0;
6411   }
6412   {
6413     try {
6414       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6415     } catch (std::out_of_range& e) {
6416       {
6417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6418       };
6419     } catch (std::exception& e) {
6420       {
6421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6422       };
6423     } catch (...) {
6424       {
6425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6426       };
6427     }
6428   }
6429   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6430   return jresult;
6431 }
6432
6433
6434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6435   void * jresult ;
6436   Dali::Vector3 *arg1 = 0 ;
6437   float *arg2 = 0 ;
6438   float *arg3 = 0 ;
6439   float temp2 ;
6440   float temp3 ;
6441   Dali::Vector3 result;
6442
6443   arg1 = (Dali::Vector3 *)jarg1;
6444   if (!arg1) {
6445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6446     return 0;
6447   }
6448   temp2 = (float)jarg2;
6449   arg2 = &temp2;
6450   temp3 = (float)jarg3;
6451   arg3 = &temp3;
6452   {
6453     try {
6454       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6455     } catch (std::out_of_range& e) {
6456       {
6457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6458       };
6459     } catch (std::exception& e) {
6460       {
6461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6462       };
6463     } catch (...) {
6464       {
6465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6466       };
6467     }
6468   }
6469   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6470   return jresult;
6471 }
6472
6473
6474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6475   void * jresult ;
6476   Dali::Vector4 *result = 0 ;
6477
6478   {
6479     try {
6480       result = (Dali::Vector4 *)new Dali::Vector4();
6481     } catch (std::out_of_range& e) {
6482       {
6483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6484       };
6485     } catch (std::exception& e) {
6486       {
6487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6488       };
6489     } catch (...) {
6490       {
6491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6492       };
6493     }
6494   }
6495   jresult = (void *)result;
6496   return jresult;
6497 }
6498
6499
6500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6501   void * jresult ;
6502   float arg1 ;
6503   float arg2 ;
6504   float arg3 ;
6505   float arg4 ;
6506   Dali::Vector4 *result = 0 ;
6507
6508   arg1 = (float)jarg1;
6509   arg2 = (float)jarg2;
6510   arg3 = (float)jarg3;
6511   arg4 = (float)jarg4;
6512   {
6513     try {
6514       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6515     } catch (std::out_of_range& e) {
6516       {
6517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6518       };
6519     } catch (std::exception& e) {
6520       {
6521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6522       };
6523     } catch (...) {
6524       {
6525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6526       };
6527     }
6528   }
6529   jresult = (void *)result;
6530   return jresult;
6531 }
6532
6533
6534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6535   void * jresult ;
6536   float *arg1 = (float *) 0 ;
6537   Dali::Vector4 *result = 0 ;
6538
6539   arg1 = jarg1;
6540   {
6541     try {
6542       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6543     } catch (std::out_of_range& e) {
6544       {
6545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6546       };
6547     } catch (std::exception& e) {
6548       {
6549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6550       };
6551     } catch (...) {
6552       {
6553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6554       };
6555     }
6556   }
6557   jresult = (void *)result;
6558
6559
6560   return jresult;
6561 }
6562
6563
6564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6565   void * jresult ;
6566   Dali::Vector2 *arg1 = 0 ;
6567   Dali::Vector4 *result = 0 ;
6568
6569   arg1 = (Dali::Vector2 *)jarg1;
6570   if (!arg1) {
6571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6572     return 0;
6573   }
6574   {
6575     try {
6576       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6577     } catch (std::out_of_range& e) {
6578       {
6579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6580       };
6581     } catch (std::exception& e) {
6582       {
6583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6584       };
6585     } catch (...) {
6586       {
6587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6588       };
6589     }
6590   }
6591   jresult = (void *)result;
6592   return jresult;
6593 }
6594
6595
6596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6597   void * jresult ;
6598   Dali::Vector3 *arg1 = 0 ;
6599   Dali::Vector4 *result = 0 ;
6600
6601   arg1 = (Dali::Vector3 *)jarg1;
6602   if (!arg1) {
6603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6604     return 0;
6605   }
6606   {
6607     try {
6608       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6609     } catch (std::out_of_range& e) {
6610       {
6611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6612       };
6613     } catch (std::exception& e) {
6614       {
6615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6616       };
6617     } catch (...) {
6618       {
6619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6620       };
6621     }
6622   }
6623   jresult = (void *)result;
6624   return jresult;
6625 }
6626
6627
6628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6629   void * jresult ;
6630   Dali::Vector4 *result = 0 ;
6631
6632   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6633   jresult = (void *)result;
6634   return jresult;
6635 }
6636
6637
6638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6639   void * jresult ;
6640   Dali::Vector4 *result = 0 ;
6641
6642   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6643   jresult = (void *)result;
6644   return jresult;
6645 }
6646
6647
6648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6649   void * jresult ;
6650   Dali::Vector4 *result = 0 ;
6651
6652   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6653   jresult = (void *)result;
6654   return jresult;
6655 }
6656
6657
6658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6659   void * jresult ;
6660   Dali::Vector4 *result = 0 ;
6661
6662   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6663   jresult = (void *)result;
6664   return jresult;
6665 }
6666
6667
6668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6669   void * jresult ;
6670   Dali::Vector4 *result = 0 ;
6671
6672   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6673   jresult = (void *)result;
6674   return jresult;
6675 }
6676
6677
6678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6679   void * jresult ;
6680   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6681   float *arg2 = (float *) 0 ;
6682   Dali::Vector4 *result = 0 ;
6683
6684   arg1 = (Dali::Vector4 *)jarg1;
6685   arg2 = jarg2;
6686   {
6687     try {
6688       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
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
6705
6706   return jresult;
6707 }
6708
6709
6710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6711   void * jresult ;
6712   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6713   Dali::Vector2 *arg2 = 0 ;
6714   Dali::Vector4 *result = 0 ;
6715
6716   arg1 = (Dali::Vector4 *)jarg1;
6717   arg2 = (Dali::Vector2 *)jarg2;
6718   if (!arg2) {
6719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6720     return 0;
6721   }
6722   {
6723     try {
6724       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6725     } catch (std::out_of_range& e) {
6726       {
6727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6728       };
6729     } catch (std::exception& e) {
6730       {
6731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6732       };
6733     } catch (...) {
6734       {
6735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6736       };
6737     }
6738   }
6739   jresult = (void *)result;
6740   return jresult;
6741 }
6742
6743
6744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6745   void * jresult ;
6746   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6747   Dali::Vector3 *arg2 = 0 ;
6748   Dali::Vector4 *result = 0 ;
6749
6750   arg1 = (Dali::Vector4 *)jarg1;
6751   arg2 = (Dali::Vector3 *)jarg2;
6752   if (!arg2) {
6753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6754     return 0;
6755   }
6756   {
6757     try {
6758       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6759     } catch (std::out_of_range& e) {
6760       {
6761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6762       };
6763     } catch (std::exception& e) {
6764       {
6765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6766       };
6767     } catch (...) {
6768       {
6769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6770       };
6771     }
6772   }
6773   jresult = (void *)result;
6774   return jresult;
6775 }
6776
6777
6778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6779   void * jresult ;
6780   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6781   Dali::Vector4 *arg2 = 0 ;
6782   Dali::Vector4 result;
6783
6784   arg1 = (Dali::Vector4 *)jarg1;
6785   arg2 = (Dali::Vector4 *)jarg2;
6786   if (!arg2) {
6787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6788     return 0;
6789   }
6790   {
6791     try {
6792       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6793     } catch (std::out_of_range& e) {
6794       {
6795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6796       };
6797     } catch (std::exception& e) {
6798       {
6799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6800       };
6801     } catch (...) {
6802       {
6803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6804       };
6805     }
6806   }
6807   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6808   return jresult;
6809 }
6810
6811
6812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6813   void * jresult ;
6814   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6815   Dali::Vector4 *arg2 = 0 ;
6816   Dali::Vector4 *result = 0 ;
6817
6818   arg1 = (Dali::Vector4 *)jarg1;
6819   arg2 = (Dali::Vector4 *)jarg2;
6820   if (!arg2) {
6821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6822     return 0;
6823   }
6824   {
6825     try {
6826       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6827     } catch (std::out_of_range& e) {
6828       {
6829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6830       };
6831     } catch (std::exception& e) {
6832       {
6833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6834       };
6835     } catch (...) {
6836       {
6837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6838       };
6839     }
6840   }
6841   jresult = (void *)result;
6842   return jresult;
6843 }
6844
6845
6846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6847   void * jresult ;
6848   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6849   Dali::Vector4 *arg2 = 0 ;
6850   Dali::Vector4 result;
6851
6852   arg1 = (Dali::Vector4 *)jarg1;
6853   arg2 = (Dali::Vector4 *)jarg2;
6854   if (!arg2) {
6855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6856     return 0;
6857   }
6858   {
6859     try {
6860       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6861     } catch (std::out_of_range& e) {
6862       {
6863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6864       };
6865     } catch (std::exception& e) {
6866       {
6867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6868       };
6869     } catch (...) {
6870       {
6871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6872       };
6873     }
6874   }
6875   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6876   return jresult;
6877 }
6878
6879
6880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6881   void * jresult ;
6882   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6883   Dali::Vector4 *arg2 = 0 ;
6884   Dali::Vector4 *result = 0 ;
6885
6886   arg1 = (Dali::Vector4 *)jarg1;
6887   arg2 = (Dali::Vector4 *)jarg2;
6888   if (!arg2) {
6889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6890     return 0;
6891   }
6892   {
6893     try {
6894       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6895     } catch (std::out_of_range& e) {
6896       {
6897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6898       };
6899     } catch (std::exception& e) {
6900       {
6901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6902       };
6903     } catch (...) {
6904       {
6905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6906       };
6907     }
6908   }
6909   jresult = (void *)result;
6910   return jresult;
6911 }
6912
6913
6914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6915   void * jresult ;
6916   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6917   Dali::Vector4 *arg2 = 0 ;
6918   Dali::Vector4 result;
6919
6920   arg1 = (Dali::Vector4 *)jarg1;
6921   arg2 = (Dali::Vector4 *)jarg2;
6922   if (!arg2) {
6923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6924     return 0;
6925   }
6926   {
6927     try {
6928       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
6929     } catch (std::out_of_range& e) {
6930       {
6931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6932       };
6933     } catch (std::exception& e) {
6934       {
6935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6936       };
6937     } catch (...) {
6938       {
6939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6940       };
6941     }
6942   }
6943   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6944   return jresult;
6945 }
6946
6947
6948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
6949   void * jresult ;
6950   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6951   float arg2 ;
6952   Dali::Vector4 result;
6953
6954   arg1 = (Dali::Vector4 *)jarg1;
6955   arg2 = (float)jarg2;
6956   {
6957     try {
6958       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
6959     } catch (std::out_of_range& e) {
6960       {
6961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6962       };
6963     } catch (std::exception& e) {
6964       {
6965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6966       };
6967     } catch (...) {
6968       {
6969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6970       };
6971     }
6972   }
6973   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6974   return jresult;
6975 }
6976
6977
6978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6979   void * jresult ;
6980   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6981   Dali::Vector4 *arg2 = 0 ;
6982   Dali::Vector4 *result = 0 ;
6983
6984   arg1 = (Dali::Vector4 *)jarg1;
6985   arg2 = (Dali::Vector4 *)jarg2;
6986   if (!arg2) {
6987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6988     return 0;
6989   }
6990   {
6991     try {
6992       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
6993     } catch (std::out_of_range& e) {
6994       {
6995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6996       };
6997     } catch (std::exception& e) {
6998       {
6999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7000       };
7001     } catch (...) {
7002       {
7003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7004       };
7005     }
7006   }
7007   jresult = (void *)result;
7008   return jresult;
7009 }
7010
7011
7012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7013   void * jresult ;
7014   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7015   float arg2 ;
7016   Dali::Vector4 *result = 0 ;
7017
7018   arg1 = (Dali::Vector4 *)jarg1;
7019   arg2 = (float)jarg2;
7020   {
7021     try {
7022       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7023     } catch (std::out_of_range& e) {
7024       {
7025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7026       };
7027     } catch (std::exception& e) {
7028       {
7029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7030       };
7031     } catch (...) {
7032       {
7033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7034       };
7035     }
7036   }
7037   jresult = (void *)result;
7038   return jresult;
7039 }
7040
7041
7042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7043   void * jresult ;
7044   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7045   Dali::Vector4 *arg2 = 0 ;
7046   Dali::Vector4 result;
7047
7048   arg1 = (Dali::Vector4 *)jarg1;
7049   arg2 = (Dali::Vector4 *)jarg2;
7050   if (!arg2) {
7051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7052     return 0;
7053   }
7054   {
7055     try {
7056       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7057     } catch (std::out_of_range& e) {
7058       {
7059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7060       };
7061     } catch (std::exception& e) {
7062       {
7063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7064       };
7065     } catch (...) {
7066       {
7067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7068       };
7069     }
7070   }
7071   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7072   return jresult;
7073 }
7074
7075
7076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7077   void * jresult ;
7078   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7079   float arg2 ;
7080   Dali::Vector4 result;
7081
7082   arg1 = (Dali::Vector4 *)jarg1;
7083   arg2 = (float)jarg2;
7084   {
7085     try {
7086       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7087     } catch (std::out_of_range& e) {
7088       {
7089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7090       };
7091     } catch (std::exception& e) {
7092       {
7093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7094       };
7095     } catch (...) {
7096       {
7097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7098       };
7099     }
7100   }
7101   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7102   return jresult;
7103 }
7104
7105
7106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7107   void * jresult ;
7108   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7109   Dali::Vector4 *arg2 = 0 ;
7110   Dali::Vector4 *result = 0 ;
7111
7112   arg1 = (Dali::Vector4 *)jarg1;
7113   arg2 = (Dali::Vector4 *)jarg2;
7114   if (!arg2) {
7115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7116     return 0;
7117   }
7118   {
7119     try {
7120       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7121     } catch (std::out_of_range& e) {
7122       {
7123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7124       };
7125     } catch (std::exception& e) {
7126       {
7127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7128       };
7129     } catch (...) {
7130       {
7131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7132       };
7133     }
7134   }
7135   jresult = (void *)result;
7136   return jresult;
7137 }
7138
7139
7140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7141   void * jresult ;
7142   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7143   float arg2 ;
7144   Dali::Vector4 *result = 0 ;
7145
7146   arg1 = (Dali::Vector4 *)jarg1;
7147   arg2 = (float)jarg2;
7148   {
7149     try {
7150       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7151     } catch (std::out_of_range& e) {
7152       {
7153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7154       };
7155     } catch (std::exception& e) {
7156       {
7157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7158       };
7159     } catch (...) {
7160       {
7161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7162       };
7163     }
7164   }
7165   jresult = (void *)result;
7166   return jresult;
7167 }
7168
7169
7170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7171   void * jresult ;
7172   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7173   Dali::Vector4 result;
7174
7175   arg1 = (Dali::Vector4 *)jarg1;
7176   {
7177     try {
7178       result = ((Dali::Vector4 const *)arg1)->operator -();
7179     } catch (std::out_of_range& e) {
7180       {
7181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7182       };
7183     } catch (std::exception& e) {
7184       {
7185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7186       };
7187     } catch (...) {
7188       {
7189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7190       };
7191     }
7192   }
7193   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7194   return jresult;
7195 }
7196
7197
7198 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7199   unsigned int jresult ;
7200   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7201   Dali::Vector4 *arg2 = 0 ;
7202   bool result;
7203
7204   arg1 = (Dali::Vector4 *)jarg1;
7205   arg2 = (Dali::Vector4 *)jarg2;
7206   if (!arg2) {
7207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7208     return 0;
7209   }
7210   {
7211     try {
7212       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7213     } catch (std::out_of_range& e) {
7214       {
7215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7216       };
7217     } catch (std::exception& e) {
7218       {
7219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7220       };
7221     } catch (...) {
7222       {
7223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7224       };
7225     }
7226   }
7227   jresult = result;
7228   return jresult;
7229 }
7230
7231
7232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7233   unsigned int jresult ;
7234   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7235   Dali::Vector4 *arg2 = 0 ;
7236   bool result;
7237
7238   arg1 = (Dali::Vector4 *)jarg1;
7239   arg2 = (Dali::Vector4 *)jarg2;
7240   if (!arg2) {
7241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7242     return 0;
7243   }
7244   {
7245     try {
7246       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7247     } catch (std::out_of_range& e) {
7248       {
7249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7250       };
7251     } catch (std::exception& e) {
7252       {
7253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7254       };
7255     } catch (...) {
7256       {
7257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7258       };
7259     }
7260   }
7261   jresult = result;
7262   return jresult;
7263 }
7264
7265
7266 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7267   float jresult ;
7268   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7269   unsigned int arg2 ;
7270   float *result = 0 ;
7271
7272   arg1 = (Dali::Vector4 *)jarg1;
7273   arg2 = (unsigned int)jarg2;
7274   {
7275     try {
7276       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7277     } catch (std::out_of_range& e) {
7278       {
7279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7280       };
7281     } catch (std::exception& e) {
7282       {
7283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7284       };
7285     } catch (...) {
7286       {
7287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7288       };
7289     }
7290   }
7291   jresult = *result;
7292   return jresult;
7293 }
7294
7295
7296 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7297   float jresult ;
7298   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7299   Dali::Vector3 *arg2 = 0 ;
7300   float result;
7301
7302   arg1 = (Dali::Vector4 *)jarg1;
7303   arg2 = (Dali::Vector3 *)jarg2;
7304   if (!arg2) {
7305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7306     return 0;
7307   }
7308   {
7309     try {
7310       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7311     } catch (std::out_of_range& e) {
7312       {
7313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7314       };
7315     } catch (std::exception& e) {
7316       {
7317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7318       };
7319     } catch (...) {
7320       {
7321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7322       };
7323     }
7324   }
7325   jresult = result;
7326   return jresult;
7327 }
7328
7329
7330 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7331   float jresult ;
7332   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7333   Dali::Vector4 *arg2 = 0 ;
7334   float result;
7335
7336   arg1 = (Dali::Vector4 *)jarg1;
7337   arg2 = (Dali::Vector4 *)jarg2;
7338   if (!arg2) {
7339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7340     return 0;
7341   }
7342   {
7343     try {
7344       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7345     } catch (std::out_of_range& e) {
7346       {
7347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7348       };
7349     } catch (std::exception& e) {
7350       {
7351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7352       };
7353     } catch (...) {
7354       {
7355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7356       };
7357     }
7358   }
7359   jresult = result;
7360   return jresult;
7361 }
7362
7363
7364 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7365   float jresult ;
7366   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7367   Dali::Vector4 *arg2 = 0 ;
7368   float result;
7369
7370   arg1 = (Dali::Vector4 *)jarg1;
7371   arg2 = (Dali::Vector4 *)jarg2;
7372   if (!arg2) {
7373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7374     return 0;
7375   }
7376   {
7377     try {
7378       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7379     } catch (std::out_of_range& e) {
7380       {
7381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7382       };
7383     } catch (std::exception& e) {
7384       {
7385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7386       };
7387     } catch (...) {
7388       {
7389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7390       };
7391     }
7392   }
7393   jresult = result;
7394   return jresult;
7395 }
7396
7397
7398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7399   void * jresult ;
7400   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7401   Dali::Vector4 *arg2 = 0 ;
7402   Dali::Vector4 result;
7403
7404   arg1 = (Dali::Vector4 *)jarg1;
7405   arg2 = (Dali::Vector4 *)jarg2;
7406   if (!arg2) {
7407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7408     return 0;
7409   }
7410   {
7411     try {
7412       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7413     } catch (std::out_of_range& e) {
7414       {
7415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7416       };
7417     } catch (std::exception& e) {
7418       {
7419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7420       };
7421     } catch (...) {
7422       {
7423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7424       };
7425     }
7426   }
7427   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7428   return jresult;
7429 }
7430
7431
7432 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7433   float jresult ;
7434   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7435   float result;
7436
7437   arg1 = (Dali::Vector4 *)jarg1;
7438   {
7439     try {
7440       result = (float)((Dali::Vector4 const *)arg1)->Length();
7441     } catch (std::out_of_range& e) {
7442       {
7443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7444       };
7445     } catch (std::exception& e) {
7446       {
7447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7448       };
7449     } catch (...) {
7450       {
7451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7452       };
7453     }
7454   }
7455   jresult = result;
7456   return jresult;
7457 }
7458
7459
7460 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7461   float jresult ;
7462   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7463   float result;
7464
7465   arg1 = (Dali::Vector4 *)jarg1;
7466   {
7467     try {
7468       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7469     } catch (std::out_of_range& e) {
7470       {
7471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7472       };
7473     } catch (std::exception& e) {
7474       {
7475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7476       };
7477     } catch (...) {
7478       {
7479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7480       };
7481     }
7482   }
7483   jresult = result;
7484   return jresult;
7485 }
7486
7487
7488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7489   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7490
7491   arg1 = (Dali::Vector4 *)jarg1;
7492   {
7493     try {
7494       (arg1)->Normalize();
7495     } catch (std::out_of_range& e) {
7496       {
7497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7498       };
7499     } catch (std::exception& e) {
7500       {
7501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7502       };
7503     } catch (...) {
7504       {
7505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7506       };
7507     }
7508   }
7509 }
7510
7511
7512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7513   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7514   Dali::Vector4 *arg2 = 0 ;
7515   Dali::Vector4 *arg3 = 0 ;
7516
7517   arg1 = (Dali::Vector4 *)jarg1;
7518   arg2 = (Dali::Vector4 *)jarg2;
7519   if (!arg2) {
7520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7521     return ;
7522   }
7523   arg3 = (Dali::Vector4 *)jarg3;
7524   if (!arg3) {
7525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7526     return ;
7527   }
7528   {
7529     try {
7530       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7531     } catch (std::out_of_range& e) {
7532       {
7533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7534       };
7535     } catch (std::exception& e) {
7536       {
7537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7538       };
7539     } catch (...) {
7540       {
7541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7542       };
7543     }
7544   }
7545 }
7546
7547
7548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7549   void * jresult ;
7550   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7551   float *result = 0 ;
7552
7553   arg1 = (Dali::Vector4 *)jarg1;
7554   {
7555     try {
7556       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7557     } catch (std::out_of_range& e) {
7558       {
7559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7560       };
7561     } catch (std::exception& e) {
7562       {
7563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7564       };
7565     } catch (...) {
7566       {
7567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7568       };
7569     }
7570   }
7571   jresult = (void *)result;
7572   return jresult;
7573 }
7574
7575
7576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7577   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7578   float arg2 ;
7579
7580   arg1 = (Dali::Vector4 *)jarg1;
7581   arg2 = (float)jarg2;
7582   if (arg1) (arg1)->x = arg2;
7583 }
7584
7585
7586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7587   float jresult ;
7588   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7589   float result;
7590
7591   arg1 = (Dali::Vector4 *)jarg1;
7592   result = (float) ((arg1)->x);
7593   jresult = result;
7594   return jresult;
7595 }
7596
7597
7598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7599   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7600   float arg2 ;
7601
7602   arg1 = (Dali::Vector4 *)jarg1;
7603   arg2 = (float)jarg2;
7604   if (arg1) (arg1)->r = arg2;
7605 }
7606
7607
7608 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7609   float jresult ;
7610   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7611   float result;
7612
7613   arg1 = (Dali::Vector4 *)jarg1;
7614   result = (float) ((arg1)->r);
7615   jresult = result;
7616   return jresult;
7617 }
7618
7619
7620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7621   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7622   float arg2 ;
7623
7624   arg1 = (Dali::Vector4 *)jarg1;
7625   arg2 = (float)jarg2;
7626   if (arg1) (arg1)->s = arg2;
7627 }
7628
7629
7630 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7631   float jresult ;
7632   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7633   float result;
7634
7635   arg1 = (Dali::Vector4 *)jarg1;
7636   result = (float) ((arg1)->s);
7637   jresult = result;
7638   return jresult;
7639 }
7640
7641
7642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7643   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7644   float arg2 ;
7645
7646   arg1 = (Dali::Vector4 *)jarg1;
7647   arg2 = (float)jarg2;
7648   if (arg1) (arg1)->y = arg2;
7649 }
7650
7651
7652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7653   float jresult ;
7654   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7655   float result;
7656
7657   arg1 = (Dali::Vector4 *)jarg1;
7658   result = (float) ((arg1)->y);
7659   jresult = result;
7660   return jresult;
7661 }
7662
7663
7664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7665   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7666   float arg2 ;
7667
7668   arg1 = (Dali::Vector4 *)jarg1;
7669   arg2 = (float)jarg2;
7670   if (arg1) (arg1)->g = arg2;
7671 }
7672
7673
7674 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7675   float jresult ;
7676   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7677   float result;
7678
7679   arg1 = (Dali::Vector4 *)jarg1;
7680   result = (float) ((arg1)->g);
7681   jresult = result;
7682   return jresult;
7683 }
7684
7685
7686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7687   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7688   float arg2 ;
7689
7690   arg1 = (Dali::Vector4 *)jarg1;
7691   arg2 = (float)jarg2;
7692   if (arg1) (arg1)->t = arg2;
7693 }
7694
7695
7696 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7697   float jresult ;
7698   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7699   float result;
7700
7701   arg1 = (Dali::Vector4 *)jarg1;
7702   result = (float) ((arg1)->t);
7703   jresult = result;
7704   return jresult;
7705 }
7706
7707
7708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7709   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7710   float arg2 ;
7711
7712   arg1 = (Dali::Vector4 *)jarg1;
7713   arg2 = (float)jarg2;
7714   if (arg1) (arg1)->z = arg2;
7715 }
7716
7717
7718 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7719   float jresult ;
7720   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7721   float result;
7722
7723   arg1 = (Dali::Vector4 *)jarg1;
7724   result = (float) ((arg1)->z);
7725   jresult = result;
7726   return jresult;
7727 }
7728
7729
7730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7731   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7732   float arg2 ;
7733
7734   arg1 = (Dali::Vector4 *)jarg1;
7735   arg2 = (float)jarg2;
7736   if (arg1) (arg1)->b = arg2;
7737 }
7738
7739
7740 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7741   float jresult ;
7742   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7743   float result;
7744
7745   arg1 = (Dali::Vector4 *)jarg1;
7746   result = (float) ((arg1)->b);
7747   jresult = result;
7748   return jresult;
7749 }
7750
7751
7752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7753   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7754   float arg2 ;
7755
7756   arg1 = (Dali::Vector4 *)jarg1;
7757   arg2 = (float)jarg2;
7758   if (arg1) (arg1)->p = arg2;
7759 }
7760
7761
7762 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7763   float jresult ;
7764   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7765   float result;
7766
7767   arg1 = (Dali::Vector4 *)jarg1;
7768   result = (float) ((arg1)->p);
7769   jresult = result;
7770   return jresult;
7771 }
7772
7773
7774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7775   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7776   float arg2 ;
7777
7778   arg1 = (Dali::Vector4 *)jarg1;
7779   arg2 = (float)jarg2;
7780   if (arg1) (arg1)->w = arg2;
7781 }
7782
7783
7784 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7785   float jresult ;
7786   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7787   float result;
7788
7789   arg1 = (Dali::Vector4 *)jarg1;
7790   result = (float) ((arg1)->w);
7791   jresult = result;
7792   return jresult;
7793 }
7794
7795
7796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7797   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7798   float arg2 ;
7799
7800   arg1 = (Dali::Vector4 *)jarg1;
7801   arg2 = (float)jarg2;
7802   if (arg1) (arg1)->a = arg2;
7803 }
7804
7805
7806 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7807   float jresult ;
7808   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7809   float result;
7810
7811   arg1 = (Dali::Vector4 *)jarg1;
7812   result = (float) ((arg1)->a);
7813   jresult = result;
7814   return jresult;
7815 }
7816
7817
7818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7819   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7820   float arg2 ;
7821
7822   arg1 = (Dali::Vector4 *)jarg1;
7823   arg2 = (float)jarg2;
7824   if (arg1) (arg1)->q = arg2;
7825 }
7826
7827
7828 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7829   float jresult ;
7830   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7831   float result;
7832
7833   arg1 = (Dali::Vector4 *)jarg1;
7834   result = (float) ((arg1)->q);
7835   jresult = result;
7836   return jresult;
7837 }
7838
7839
7840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7841   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7842
7843   arg1 = (Dali::Vector4 *)jarg1;
7844   {
7845     try {
7846       delete arg1;
7847     } catch (std::out_of_range& e) {
7848       {
7849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7850       };
7851     } catch (std::exception& e) {
7852       {
7853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7854       };
7855     } catch (...) {
7856       {
7857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7858       };
7859     }
7860   }
7861 }
7862
7863
7864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7865   void * jresult ;
7866   Dali::Vector4 *arg1 = 0 ;
7867   Dali::Vector4 *arg2 = 0 ;
7868   Dali::Vector4 result;
7869
7870   arg1 = (Dali::Vector4 *)jarg1;
7871   if (!arg1) {
7872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7873     return 0;
7874   }
7875   arg2 = (Dali::Vector4 *)jarg2;
7876   if (!arg2) {
7877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7878     return 0;
7879   }
7880   {
7881     try {
7882       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7883     } catch (std::out_of_range& e) {
7884       {
7885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7886       };
7887     } catch (std::exception& e) {
7888       {
7889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7890       };
7891     } catch (...) {
7892       {
7893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7894       };
7895     }
7896   }
7897   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7898   return jresult;
7899 }
7900
7901
7902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
7903   void * jresult ;
7904   Dali::Vector4 *arg1 = 0 ;
7905   Dali::Vector4 *arg2 = 0 ;
7906   Dali::Vector4 result;
7907
7908   arg1 = (Dali::Vector4 *)jarg1;
7909   if (!arg1) {
7910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7911     return 0;
7912   }
7913   arg2 = (Dali::Vector4 *)jarg2;
7914   if (!arg2) {
7915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7916     return 0;
7917   }
7918   {
7919     try {
7920       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7921     } catch (std::out_of_range& e) {
7922       {
7923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7924       };
7925     } catch (std::exception& e) {
7926       {
7927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7928       };
7929     } catch (...) {
7930       {
7931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7932       };
7933     }
7934   }
7935   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7936   return jresult;
7937 }
7938
7939
7940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
7941   void * jresult ;
7942   Dali::Vector4 *arg1 = 0 ;
7943   float *arg2 = 0 ;
7944   float *arg3 = 0 ;
7945   float temp2 ;
7946   float temp3 ;
7947   Dali::Vector4 result;
7948
7949   arg1 = (Dali::Vector4 *)jarg1;
7950   if (!arg1) {
7951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7952     return 0;
7953   }
7954   temp2 = (float)jarg2;
7955   arg2 = &temp2;
7956   temp3 = (float)jarg3;
7957   arg3 = &temp3;
7958   {
7959     try {
7960       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7961     } catch (std::out_of_range& e) {
7962       {
7963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7964       };
7965     } catch (std::exception& e) {
7966       {
7967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7968       };
7969     } catch (...) {
7970       {
7971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7972       };
7973     }
7974   }
7975   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7976   return jresult;
7977 }
7978
7979
7980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
7981   void * jresult ;
7982   Dali::Uint16Pair *result = 0 ;
7983
7984   {
7985     try {
7986       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
7987     } catch (std::out_of_range& e) {
7988       {
7989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7990       };
7991     } catch (std::exception& e) {
7992       {
7993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7994       };
7995     } catch (...) {
7996       {
7997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7998       };
7999     }
8000   }
8001   jresult = (void *)result;
8002   return jresult;
8003 }
8004
8005
8006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8007   void * jresult ;
8008   uint32_t arg1 ;
8009   uint32_t arg2 ;
8010   Dali::Uint16Pair *result = 0 ;
8011
8012   arg1 = (uint32_t)jarg1;
8013   arg2 = (uint32_t)jarg2;
8014   {
8015     try {
8016       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8017     } catch (std::out_of_range& e) {
8018       {
8019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8020       };
8021     } catch (std::exception& e) {
8022       {
8023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8024       };
8025     } catch (...) {
8026       {
8027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8028       };
8029     }
8030   }
8031   jresult = (void *)result;
8032   return jresult;
8033 }
8034
8035
8036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8037   void * jresult ;
8038   Dali::Uint16Pair *arg1 = 0 ;
8039   Dali::Uint16Pair *result = 0 ;
8040
8041   arg1 = (Dali::Uint16Pair *)jarg1;
8042   if (!arg1) {
8043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8044     return 0;
8045   }
8046   {
8047     try {
8048       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8049     } catch (std::out_of_range& e) {
8050       {
8051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8052       };
8053     } catch (std::exception& e) {
8054       {
8055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8056       };
8057     } catch (...) {
8058       {
8059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8060       };
8061     }
8062   }
8063   jresult = (void *)result;
8064   return jresult;
8065 }
8066
8067
8068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8069   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8070   uint16_t arg2 ;
8071
8072   arg1 = (Dali::Uint16Pair *)jarg1;
8073   arg2 = (uint16_t)jarg2;
8074   {
8075     try {
8076       (arg1)->SetWidth(arg2);
8077     } catch (std::out_of_range& e) {
8078       {
8079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8080       };
8081     } catch (std::exception& e) {
8082       {
8083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8084       };
8085     } catch (...) {
8086       {
8087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8088       };
8089     }
8090   }
8091 }
8092
8093
8094 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8095   unsigned short jresult ;
8096   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8097   uint16_t result;
8098
8099   arg1 = (Dali::Uint16Pair *)jarg1;
8100   {
8101     try {
8102       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8103     } catch (std::out_of_range& e) {
8104       {
8105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8106       };
8107     } catch (std::exception& e) {
8108       {
8109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8110       };
8111     } catch (...) {
8112       {
8113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8114       };
8115     }
8116   }
8117   jresult = result;
8118   return jresult;
8119 }
8120
8121
8122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8123   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8124   uint16_t arg2 ;
8125
8126   arg1 = (Dali::Uint16Pair *)jarg1;
8127   arg2 = (uint16_t)jarg2;
8128   {
8129     try {
8130       (arg1)->SetHeight(arg2);
8131     } catch (std::out_of_range& e) {
8132       {
8133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8134       };
8135     } catch (std::exception& e) {
8136       {
8137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8138       };
8139     } catch (...) {
8140       {
8141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8142       };
8143     }
8144   }
8145 }
8146
8147
8148 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8149   unsigned short jresult ;
8150   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8151   uint16_t result;
8152
8153   arg1 = (Dali::Uint16Pair *)jarg1;
8154   {
8155     try {
8156       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8157     } catch (std::out_of_range& e) {
8158       {
8159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8160       };
8161     } catch (std::exception& e) {
8162       {
8163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8164       };
8165     } catch (...) {
8166       {
8167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8168       };
8169     }
8170   }
8171   jresult = result;
8172   return jresult;
8173 }
8174
8175
8176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8177   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8178   uint16_t arg2 ;
8179
8180   arg1 = (Dali::Uint16Pair *)jarg1;
8181   arg2 = (uint16_t)jarg2;
8182   {
8183     try {
8184       (arg1)->SetX(arg2);
8185     } catch (std::out_of_range& e) {
8186       {
8187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8188       };
8189     } catch (std::exception& e) {
8190       {
8191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8192       };
8193     } catch (...) {
8194       {
8195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8196       };
8197     }
8198   }
8199 }
8200
8201
8202 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8203   unsigned short jresult ;
8204   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8205   uint16_t result;
8206
8207   arg1 = (Dali::Uint16Pair *)jarg1;
8208   {
8209     try {
8210       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8211     } catch (std::out_of_range& e) {
8212       {
8213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8214       };
8215     } catch (std::exception& e) {
8216       {
8217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8218       };
8219     } catch (...) {
8220       {
8221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8222       };
8223     }
8224   }
8225   jresult = result;
8226   return jresult;
8227 }
8228
8229
8230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8231   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8232   uint16_t arg2 ;
8233
8234   arg1 = (Dali::Uint16Pair *)jarg1;
8235   arg2 = (uint16_t)jarg2;
8236   {
8237     try {
8238       (arg1)->SetY(arg2);
8239     } catch (std::out_of_range& e) {
8240       {
8241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8242       };
8243     } catch (std::exception& e) {
8244       {
8245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8246       };
8247     } catch (...) {
8248       {
8249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8250       };
8251     }
8252   }
8253 }
8254
8255
8256 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8257   unsigned short jresult ;
8258   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8259   uint16_t result;
8260
8261   arg1 = (Dali::Uint16Pair *)jarg1;
8262   {
8263     try {
8264       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8265     } catch (std::out_of_range& e) {
8266       {
8267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8268       };
8269     } catch (std::exception& e) {
8270       {
8271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8272       };
8273     } catch (...) {
8274       {
8275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8276       };
8277     }
8278   }
8279   jresult = result;
8280   return jresult;
8281 }
8282
8283
8284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8285   void * jresult ;
8286   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8287   Dali::Uint16Pair *arg2 = 0 ;
8288   Dali::Uint16Pair *result = 0 ;
8289
8290   arg1 = (Dali::Uint16Pair *)jarg1;
8291   arg2 = (Dali::Uint16Pair *)jarg2;
8292   if (!arg2) {
8293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8294     return 0;
8295   }
8296   {
8297     try {
8298       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8299     } catch (std::out_of_range& e) {
8300       {
8301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8302       };
8303     } catch (std::exception& e) {
8304       {
8305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8306       };
8307     } catch (...) {
8308       {
8309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8310       };
8311     }
8312   }
8313   jresult = (void *)result;
8314   return jresult;
8315 }
8316
8317
8318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8319   unsigned int jresult ;
8320   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8321   Dali::Uint16Pair *arg2 = 0 ;
8322   bool result;
8323
8324   arg1 = (Dali::Uint16Pair *)jarg1;
8325   arg2 = (Dali::Uint16Pair *)jarg2;
8326   if (!arg2) {
8327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8328     return 0;
8329   }
8330   {
8331     try {
8332       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8333     } catch (std::out_of_range& e) {
8334       {
8335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8336       };
8337     } catch (std::exception& e) {
8338       {
8339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8340       };
8341     } catch (...) {
8342       {
8343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8344       };
8345     }
8346   }
8347   jresult = result;
8348   return jresult;
8349 }
8350
8351
8352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8353   unsigned int jresult ;
8354   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8355   Dali::Uint16Pair *arg2 = 0 ;
8356   bool result;
8357
8358   arg1 = (Dali::Uint16Pair *)jarg1;
8359   arg2 = (Dali::Uint16Pair *)jarg2;
8360   if (!arg2) {
8361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8362     return 0;
8363   }
8364   {
8365     try {
8366       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8367     } catch (std::out_of_range& e) {
8368       {
8369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8370       };
8371     } catch (std::exception& e) {
8372       {
8373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8374       };
8375     } catch (...) {
8376       {
8377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8378       };
8379     }
8380   }
8381   jresult = result;
8382   return jresult;
8383 }
8384
8385
8386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8387   unsigned int jresult ;
8388   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8389   Dali::Uint16Pair *arg2 = 0 ;
8390   bool result;
8391
8392   arg1 = (Dali::Uint16Pair *)jarg1;
8393   arg2 = (Dali::Uint16Pair *)jarg2;
8394   if (!arg2) {
8395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8396     return 0;
8397   }
8398   {
8399     try {
8400       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8401     } catch (std::out_of_range& e) {
8402       {
8403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8404       };
8405     } catch (std::exception& e) {
8406       {
8407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8408       };
8409     } catch (...) {
8410       {
8411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8412       };
8413     }
8414   }
8415   jresult = result;
8416   return jresult;
8417 }
8418
8419
8420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8421   unsigned int jresult ;
8422   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8423   Dali::Uint16Pair *arg2 = 0 ;
8424   bool result;
8425
8426   arg1 = (Dali::Uint16Pair *)jarg1;
8427   arg2 = (Dali::Uint16Pair *)jarg2;
8428   if (!arg2) {
8429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8430     return 0;
8431   }
8432   {
8433     try {
8434       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8435     } catch (std::out_of_range& e) {
8436       {
8437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8438       };
8439     } catch (std::exception& e) {
8440       {
8441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8442       };
8443     } catch (...) {
8444       {
8445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8446       };
8447     }
8448   }
8449   jresult = result;
8450   return jresult;
8451 }
8452
8453
8454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8455   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8456
8457   arg1 = (Dali::Uint16Pair *)jarg1;
8458   {
8459     try {
8460       delete arg1;
8461     } catch (std::out_of_range& e) {
8462       {
8463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8464       };
8465     } catch (std::exception& e) {
8466       {
8467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8468       };
8469     } catch (...) {
8470       {
8471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8472       };
8473     }
8474   }
8475 }
8476
8477
8478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8479   void * jresult ;
8480   Dali::Degree *result = 0 ;
8481
8482   {
8483     try {
8484       result = (Dali::Degree *)new Dali::Degree();
8485     } catch (std::out_of_range& e) {
8486       {
8487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8488       };
8489     } catch (std::exception& e) {
8490       {
8491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8492       };
8493     } catch (...) {
8494       {
8495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8496       };
8497     }
8498   }
8499   jresult = (void *)result;
8500   return jresult;
8501 }
8502
8503
8504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8505   void * jresult ;
8506   float arg1 ;
8507   Dali::Degree *result = 0 ;
8508
8509   arg1 = (float)jarg1;
8510   {
8511     try {
8512       result = (Dali::Degree *)new Dali::Degree(arg1);
8513     } catch (std::out_of_range& e) {
8514       {
8515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8516       };
8517     } catch (std::exception& e) {
8518       {
8519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8520       };
8521     } catch (...) {
8522       {
8523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8524       };
8525     }
8526   }
8527   jresult = (void *)result;
8528   return jresult;
8529 }
8530
8531
8532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8533   void * jresult ;
8534   Dali::Radian arg1 ;
8535   Dali::Radian *argp1 ;
8536   Dali::Degree *result = 0 ;
8537
8538   argp1 = (Dali::Radian *)jarg1;
8539   if (!argp1) {
8540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8541     return 0;
8542   }
8543   arg1 = *argp1;
8544   {
8545     try {
8546       result = (Dali::Degree *)new Dali::Degree(arg1);
8547     } catch (std::out_of_range& e) {
8548       {
8549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8550       };
8551     } catch (std::exception& e) {
8552       {
8553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8554       };
8555     } catch (...) {
8556       {
8557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8558       };
8559     }
8560   }
8561   jresult = (void *)result;
8562   return jresult;
8563 }
8564
8565
8566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8567   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8568   float arg2 ;
8569
8570   arg1 = (Dali::Degree *)jarg1;
8571   arg2 = (float)jarg2;
8572   if (arg1) (arg1)->degree = arg2;
8573 }
8574
8575
8576 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8577   float jresult ;
8578   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8579   float result;
8580
8581   arg1 = (Dali::Degree *)jarg1;
8582   result = (float) ((arg1)->degree);
8583   jresult = result;
8584   return jresult;
8585 }
8586
8587
8588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8589   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8590
8591   arg1 = (Dali::Degree *)jarg1;
8592   {
8593     try {
8594       delete arg1;
8595     } catch (std::out_of_range& e) {
8596       {
8597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8598       };
8599     } catch (std::exception& e) {
8600       {
8601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8602       };
8603     } catch (...) {
8604       {
8605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8606       };
8607     }
8608   }
8609 }
8610
8611
8612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8613   void * jresult ;
8614   Dali::Radian *result = 0 ;
8615
8616   result = (Dali::Radian *)&Dali::ANGLE_360;
8617   jresult = (void *)result;
8618   return jresult;
8619 }
8620
8621
8622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8623   void * jresult ;
8624   Dali::Radian *result = 0 ;
8625
8626   result = (Dali::Radian *)&Dali::ANGLE_315;
8627   jresult = (void *)result;
8628   return jresult;
8629 }
8630
8631
8632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8633   void * jresult ;
8634   Dali::Radian *result = 0 ;
8635
8636   result = (Dali::Radian *)&Dali::ANGLE_270;
8637   jresult = (void *)result;
8638   return jresult;
8639 }
8640
8641
8642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8643   void * jresult ;
8644   Dali::Radian *result = 0 ;
8645
8646   result = (Dali::Radian *)&Dali::ANGLE_225;
8647   jresult = (void *)result;
8648   return jresult;
8649 }
8650
8651
8652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8653   void * jresult ;
8654   Dali::Radian *result = 0 ;
8655
8656   result = (Dali::Radian *)&Dali::ANGLE_180;
8657   jresult = (void *)result;
8658   return jresult;
8659 }
8660
8661
8662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8663   void * jresult ;
8664   Dali::Radian *result = 0 ;
8665
8666   result = (Dali::Radian *)&Dali::ANGLE_135;
8667   jresult = (void *)result;
8668   return jresult;
8669 }
8670
8671
8672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8673   void * jresult ;
8674   Dali::Radian *result = 0 ;
8675
8676   result = (Dali::Radian *)&Dali::ANGLE_120;
8677   jresult = (void *)result;
8678   return jresult;
8679 }
8680
8681
8682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8683   void * jresult ;
8684   Dali::Radian *result = 0 ;
8685
8686   result = (Dali::Radian *)&Dali::ANGLE_90;
8687   jresult = (void *)result;
8688   return jresult;
8689 }
8690
8691
8692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8693   void * jresult ;
8694   Dali::Radian *result = 0 ;
8695
8696   result = (Dali::Radian *)&Dali::ANGLE_60;
8697   jresult = (void *)result;
8698   return jresult;
8699 }
8700
8701
8702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8703   void * jresult ;
8704   Dali::Radian *result = 0 ;
8705
8706   result = (Dali::Radian *)&Dali::ANGLE_45;
8707   jresult = (void *)result;
8708   return jresult;
8709 }
8710
8711
8712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8713   void * jresult ;
8714   Dali::Radian *result = 0 ;
8715
8716   result = (Dali::Radian *)&Dali::ANGLE_30;
8717   jresult = (void *)result;
8718   return jresult;
8719 }
8720
8721
8722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8723   void * jresult ;
8724   Dali::Radian *result = 0 ;
8725
8726   result = (Dali::Radian *)&Dali::ANGLE_0;
8727   jresult = (void *)result;
8728   return jresult;
8729 }
8730
8731
8732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8733   unsigned int jresult ;
8734   Dali::Degree *arg1 = 0 ;
8735   Dali::Degree *arg2 = 0 ;
8736   bool result;
8737
8738   arg1 = (Dali::Degree *)jarg1;
8739   if (!arg1) {
8740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8741     return 0;
8742   }
8743   arg2 = (Dali::Degree *)jarg2;
8744   if (!arg2) {
8745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8746     return 0;
8747   }
8748   {
8749     try {
8750       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8751     } catch (std::out_of_range& e) {
8752       {
8753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8754       };
8755     } catch (std::exception& e) {
8756       {
8757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8758       };
8759     } catch (...) {
8760       {
8761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8762       };
8763     }
8764   }
8765   jresult = result;
8766   return jresult;
8767 }
8768
8769
8770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8771   unsigned int jresult ;
8772   Dali::Degree *arg1 = 0 ;
8773   Dali::Degree *arg2 = 0 ;
8774   bool result;
8775
8776   arg1 = (Dali::Degree *)jarg1;
8777   if (!arg1) {
8778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8779     return 0;
8780   }
8781   arg2 = (Dali::Degree *)jarg2;
8782   if (!arg2) {
8783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8784     return 0;
8785   }
8786   {
8787     try {
8788       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8789     } catch (std::out_of_range& e) {
8790       {
8791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8792       };
8793     } catch (std::exception& e) {
8794       {
8795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8796       };
8797     } catch (...) {
8798       {
8799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8800       };
8801     }
8802   }
8803   jresult = result;
8804   return jresult;
8805 }
8806
8807
8808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8809   void * jresult ;
8810   Dali::Degree arg1 ;
8811   float arg2 ;
8812   float arg3 ;
8813   Dali::Degree *argp1 ;
8814   Dali::Degree result;
8815
8816   argp1 = (Dali::Degree *)jarg1;
8817   if (!argp1) {
8818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8819     return 0;
8820   }
8821   arg1 = *argp1;
8822   arg2 = (float)jarg2;
8823   arg3 = (float)jarg3;
8824   {
8825     try {
8826       result = Dali::Clamp(arg1,arg2,arg3);
8827     } catch (std::out_of_range& e) {
8828       {
8829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8830       };
8831     } catch (std::exception& e) {
8832       {
8833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8834       };
8835     } catch (...) {
8836       {
8837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8838       };
8839     }
8840   }
8841   jresult = new Dali::Degree((const Dali::Degree &)result);
8842   return jresult;
8843 }
8844
8845
8846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8847   void * jresult ;
8848   Dali::Radian *result = 0 ;
8849
8850   {
8851     try {
8852       result = (Dali::Radian *)new Dali::Radian();
8853     } catch (std::out_of_range& e) {
8854       {
8855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8856       };
8857     } catch (std::exception& e) {
8858       {
8859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8860       };
8861     } catch (...) {
8862       {
8863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8864       };
8865     }
8866   }
8867   jresult = (void *)result;
8868   return jresult;
8869 }
8870
8871
8872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8873   void * jresult ;
8874   float arg1 ;
8875   Dali::Radian *result = 0 ;
8876
8877   arg1 = (float)jarg1;
8878   {
8879     try {
8880       result = (Dali::Radian *)new Dali::Radian(arg1);
8881     } catch (std::out_of_range& e) {
8882       {
8883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8884       };
8885     } catch (std::exception& e) {
8886       {
8887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8888       };
8889     } catch (...) {
8890       {
8891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8892       };
8893     }
8894   }
8895   jresult = (void *)result;
8896   return jresult;
8897 }
8898
8899
8900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
8901   void * jresult ;
8902   Dali::Degree arg1 ;
8903   Dali::Degree *argp1 ;
8904   Dali::Radian *result = 0 ;
8905
8906   argp1 = (Dali::Degree *)jarg1;
8907   if (!argp1) {
8908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8909     return 0;
8910   }
8911   arg1 = *argp1;
8912   {
8913     try {
8914       result = (Dali::Radian *)new Dali::Radian(arg1);
8915     } catch (std::out_of_range& e) {
8916       {
8917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8918       };
8919     } catch (std::exception& e) {
8920       {
8921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8922       };
8923     } catch (...) {
8924       {
8925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8926       };
8927     }
8928   }
8929   jresult = (void *)result;
8930   return jresult;
8931 }
8932
8933
8934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
8935   void * jresult ;
8936   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8937   float arg2 ;
8938   Dali::Radian *result = 0 ;
8939
8940   arg1 = (Dali::Radian *)jarg1;
8941   arg2 = (float)jarg2;
8942   {
8943     try {
8944       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8945     } catch (std::out_of_range& e) {
8946       {
8947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8948       };
8949     } catch (std::exception& e) {
8950       {
8951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8952       };
8953     } catch (...) {
8954       {
8955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8956       };
8957     }
8958   }
8959   jresult = (void *)result;
8960   return jresult;
8961 }
8962
8963
8964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
8965   void * jresult ;
8966   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8967   Dali::Degree arg2 ;
8968   Dali::Degree *argp2 ;
8969   Dali::Radian *result = 0 ;
8970
8971   arg1 = (Dali::Radian *)jarg1;
8972   argp2 = (Dali::Degree *)jarg2;
8973   if (!argp2) {
8974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8975     return 0;
8976   }
8977   arg2 = *argp2;
8978   {
8979     try {
8980       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8981     } catch (std::out_of_range& e) {
8982       {
8983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8984       };
8985     } catch (std::exception& e) {
8986       {
8987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8988       };
8989     } catch (...) {
8990       {
8991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8992       };
8993     }
8994   }
8995   jresult = (void *)result;
8996   return jresult;
8997 }
8998
8999
9000 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9001   float jresult ;
9002   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9003   float result;
9004
9005   arg1 = (Dali::Radian *)jarg1;
9006   {
9007     try {
9008       result = (float)((Dali::Radian const *)arg1)->operator float();
9009     } catch (std::out_of_range& e) {
9010       {
9011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9012       };
9013     } catch (std::exception& e) {
9014       {
9015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9016       };
9017     } catch (...) {
9018       {
9019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9020       };
9021     }
9022   }
9023   jresult = result;
9024   return jresult;
9025 }
9026
9027
9028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9029   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9030   float arg2 ;
9031
9032   arg1 = (Dali::Radian *)jarg1;
9033   arg2 = (float)jarg2;
9034   if (arg1) (arg1)->radian = arg2;
9035 }
9036
9037
9038 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9039   float jresult ;
9040   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9041   float result;
9042
9043   arg1 = (Dali::Radian *)jarg1;
9044   result = (float) ((arg1)->radian);
9045   jresult = result;
9046   return jresult;
9047 }
9048
9049
9050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9051   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9052
9053   arg1 = (Dali::Radian *)jarg1;
9054   {
9055     try {
9056       delete arg1;
9057     } catch (std::out_of_range& e) {
9058       {
9059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9060       };
9061     } catch (std::exception& e) {
9062       {
9063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9064       };
9065     } catch (...) {
9066       {
9067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9068       };
9069     }
9070   }
9071 }
9072
9073
9074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9075   unsigned int jresult ;
9076   Dali::Radian arg1 ;
9077   Dali::Radian arg2 ;
9078   Dali::Radian *argp1 ;
9079   Dali::Radian *argp2 ;
9080   bool result;
9081
9082   argp1 = (Dali::Radian *)jarg1;
9083   if (!argp1) {
9084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9085     return 0;
9086   }
9087   arg1 = *argp1;
9088   argp2 = (Dali::Radian *)jarg2;
9089   if (!argp2) {
9090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9091     return 0;
9092   }
9093   arg2 = *argp2;
9094   {
9095     try {
9096       result = (bool)Dali::operator ==(arg1,arg2);
9097     } catch (std::out_of_range& e) {
9098       {
9099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9100       };
9101     } catch (std::exception& e) {
9102       {
9103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9104       };
9105     } catch (...) {
9106       {
9107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9108       };
9109     }
9110   }
9111   jresult = result;
9112   return jresult;
9113 }
9114
9115
9116 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9117   unsigned int jresult ;
9118   Dali::Radian arg1 ;
9119   Dali::Radian arg2 ;
9120   Dali::Radian *argp1 ;
9121   Dali::Radian *argp2 ;
9122   bool result;
9123
9124   argp1 = (Dali::Radian *)jarg1;
9125   if (!argp1) {
9126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9127     return 0;
9128   }
9129   arg1 = *argp1;
9130   argp2 = (Dali::Radian *)jarg2;
9131   if (!argp2) {
9132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9133     return 0;
9134   }
9135   arg2 = *argp2;
9136   {
9137     try {
9138       result = (bool)Dali::operator !=(arg1,arg2);
9139     } catch (std::out_of_range& e) {
9140       {
9141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9142       };
9143     } catch (std::exception& e) {
9144       {
9145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9146       };
9147     } catch (...) {
9148       {
9149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9150       };
9151     }
9152   }
9153   jresult = result;
9154   return jresult;
9155 }
9156
9157
9158 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9159   unsigned int jresult ;
9160   Dali::Radian arg1 ;
9161   Dali::Degree arg2 ;
9162   Dali::Radian *argp1 ;
9163   Dali::Degree *argp2 ;
9164   bool result;
9165
9166   argp1 = (Dali::Radian *)jarg1;
9167   if (!argp1) {
9168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9169     return 0;
9170   }
9171   arg1 = *argp1;
9172   argp2 = (Dali::Degree *)jarg2;
9173   if (!argp2) {
9174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9175     return 0;
9176   }
9177   arg2 = *argp2;
9178   {
9179     try {
9180       result = (bool)Dali::operator ==(arg1,arg2);
9181     } catch (std::out_of_range& e) {
9182       {
9183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9184       };
9185     } catch (std::exception& e) {
9186       {
9187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9188       };
9189     } catch (...) {
9190       {
9191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9192       };
9193     }
9194   }
9195   jresult = result;
9196   return jresult;
9197 }
9198
9199
9200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9201   unsigned int jresult ;
9202   Dali::Radian arg1 ;
9203   Dali::Degree arg2 ;
9204   Dali::Radian *argp1 ;
9205   Dali::Degree *argp2 ;
9206   bool result;
9207
9208   argp1 = (Dali::Radian *)jarg1;
9209   if (!argp1) {
9210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9211     return 0;
9212   }
9213   arg1 = *argp1;
9214   argp2 = (Dali::Degree *)jarg2;
9215   if (!argp2) {
9216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9217     return 0;
9218   }
9219   arg2 = *argp2;
9220   {
9221     try {
9222       result = (bool)Dali::operator !=(arg1,arg2);
9223     } catch (std::out_of_range& e) {
9224       {
9225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9226       };
9227     } catch (std::exception& e) {
9228       {
9229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9230       };
9231     } catch (...) {
9232       {
9233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9234       };
9235     }
9236   }
9237   jresult = result;
9238   return jresult;
9239 }
9240
9241
9242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9243   unsigned int jresult ;
9244   Dali::Degree arg1 ;
9245   Dali::Radian arg2 ;
9246   Dali::Degree *argp1 ;
9247   Dali::Radian *argp2 ;
9248   bool result;
9249
9250   argp1 = (Dali::Degree *)jarg1;
9251   if (!argp1) {
9252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9253     return 0;
9254   }
9255   arg1 = *argp1;
9256   argp2 = (Dali::Radian *)jarg2;
9257   if (!argp2) {
9258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9259     return 0;
9260   }
9261   arg2 = *argp2;
9262   {
9263     try {
9264       result = (bool)Dali::operator ==(arg1,arg2);
9265     } catch (std::out_of_range& e) {
9266       {
9267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9268       };
9269     } catch (std::exception& e) {
9270       {
9271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9272       };
9273     } catch (...) {
9274       {
9275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9276       };
9277     }
9278   }
9279   jresult = result;
9280   return jresult;
9281 }
9282
9283
9284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9285   unsigned int jresult ;
9286   Dali::Degree arg1 ;
9287   Dali::Radian arg2 ;
9288   Dali::Degree *argp1 ;
9289   Dali::Radian *argp2 ;
9290   bool result;
9291
9292   argp1 = (Dali::Degree *)jarg1;
9293   if (!argp1) {
9294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9295     return 0;
9296   }
9297   arg1 = *argp1;
9298   argp2 = (Dali::Radian *)jarg2;
9299   if (!argp2) {
9300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9301     return 0;
9302   }
9303   arg2 = *argp2;
9304   {
9305     try {
9306       result = (bool)Dali::operator !=(arg1,arg2);
9307     } catch (std::out_of_range& e) {
9308       {
9309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9310       };
9311     } catch (std::exception& e) {
9312       {
9313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9314       };
9315     } catch (...) {
9316       {
9317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9318       };
9319     }
9320   }
9321   jresult = result;
9322   return jresult;
9323 }
9324
9325
9326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9327   unsigned int jresult ;
9328   Dali::Radian arg1 ;
9329   Dali::Radian arg2 ;
9330   Dali::Radian *argp1 ;
9331   Dali::Radian *argp2 ;
9332   bool result;
9333
9334   argp1 = (Dali::Radian *)jarg1;
9335   if (!argp1) {
9336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9337     return 0;
9338   }
9339   arg1 = *argp1;
9340   argp2 = (Dali::Radian *)jarg2;
9341   if (!argp2) {
9342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9343     return 0;
9344   }
9345   arg2 = *argp2;
9346   {
9347     try {
9348       result = (bool)Dali::operator >(arg1,arg2);
9349     } catch (std::out_of_range& e) {
9350       {
9351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9352       };
9353     } catch (std::exception& e) {
9354       {
9355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9356       };
9357     } catch (...) {
9358       {
9359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9360       };
9361     }
9362   }
9363   jresult = result;
9364   return jresult;
9365 }
9366
9367
9368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9369   unsigned int jresult ;
9370   Dali::Radian arg1 ;
9371   Dali::Degree arg2 ;
9372   Dali::Radian *argp1 ;
9373   Dali::Degree *argp2 ;
9374   bool result;
9375
9376   argp1 = (Dali::Radian *)jarg1;
9377   if (!argp1) {
9378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9379     return 0;
9380   }
9381   arg1 = *argp1;
9382   argp2 = (Dali::Degree *)jarg2;
9383   if (!argp2) {
9384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9385     return 0;
9386   }
9387   arg2 = *argp2;
9388   {
9389     try {
9390       result = (bool)Dali::operator >(arg1,arg2);
9391     } catch (std::out_of_range& e) {
9392       {
9393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9394       };
9395     } catch (std::exception& e) {
9396       {
9397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9398       };
9399     } catch (...) {
9400       {
9401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9402       };
9403     }
9404   }
9405   jresult = result;
9406   return jresult;
9407 }
9408
9409
9410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9411   unsigned int jresult ;
9412   Dali::Degree arg1 ;
9413   Dali::Radian arg2 ;
9414   Dali::Degree *argp1 ;
9415   Dali::Radian *argp2 ;
9416   bool result;
9417
9418   argp1 = (Dali::Degree *)jarg1;
9419   if (!argp1) {
9420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9421     return 0;
9422   }
9423   arg1 = *argp1;
9424   argp2 = (Dali::Radian *)jarg2;
9425   if (!argp2) {
9426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9427     return 0;
9428   }
9429   arg2 = *argp2;
9430   {
9431     try {
9432       result = (bool)Dali::operator >(arg1,arg2);
9433     } catch (std::out_of_range& e) {
9434       {
9435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9436       };
9437     } catch (std::exception& e) {
9438       {
9439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9440       };
9441     } catch (...) {
9442       {
9443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9444       };
9445     }
9446   }
9447   jresult = result;
9448   return jresult;
9449 }
9450
9451
9452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9453   unsigned int jresult ;
9454   Dali::Radian arg1 ;
9455   Dali::Radian arg2 ;
9456   Dali::Radian *argp1 ;
9457   Dali::Radian *argp2 ;
9458   bool result;
9459
9460   argp1 = (Dali::Radian *)jarg1;
9461   if (!argp1) {
9462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9463     return 0;
9464   }
9465   arg1 = *argp1;
9466   argp2 = (Dali::Radian *)jarg2;
9467   if (!argp2) {
9468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9469     return 0;
9470   }
9471   arg2 = *argp2;
9472   {
9473     try {
9474       result = (bool)Dali::operator <(arg1,arg2);
9475     } catch (std::out_of_range& e) {
9476       {
9477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9478       };
9479     } catch (std::exception& e) {
9480       {
9481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9482       };
9483     } catch (...) {
9484       {
9485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9486       };
9487     }
9488   }
9489   jresult = result;
9490   return jresult;
9491 }
9492
9493
9494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9495   unsigned int jresult ;
9496   Dali::Radian arg1 ;
9497   Dali::Degree arg2 ;
9498   Dali::Radian *argp1 ;
9499   Dali::Degree *argp2 ;
9500   bool result;
9501
9502   argp1 = (Dali::Radian *)jarg1;
9503   if (!argp1) {
9504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9505     return 0;
9506   }
9507   arg1 = *argp1;
9508   argp2 = (Dali::Degree *)jarg2;
9509   if (!argp2) {
9510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9511     return 0;
9512   }
9513   arg2 = *argp2;
9514   {
9515     try {
9516       result = (bool)Dali::operator <(arg1,arg2);
9517     } catch (std::out_of_range& e) {
9518       {
9519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9520       };
9521     } catch (std::exception& e) {
9522       {
9523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9524       };
9525     } catch (...) {
9526       {
9527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9528       };
9529     }
9530   }
9531   jresult = result;
9532   return jresult;
9533 }
9534
9535
9536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9537   unsigned int jresult ;
9538   Dali::Degree arg1 ;
9539   Dali::Radian arg2 ;
9540   Dali::Degree *argp1 ;
9541   Dali::Radian *argp2 ;
9542   bool result;
9543
9544   argp1 = (Dali::Degree *)jarg1;
9545   if (!argp1) {
9546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9547     return 0;
9548   }
9549   arg1 = *argp1;
9550   argp2 = (Dali::Radian *)jarg2;
9551   if (!argp2) {
9552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9553     return 0;
9554   }
9555   arg2 = *argp2;
9556   {
9557     try {
9558       result = (bool)Dali::operator <(arg1,arg2);
9559     } catch (std::out_of_range& e) {
9560       {
9561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9562       };
9563     } catch (std::exception& e) {
9564       {
9565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9566       };
9567     } catch (...) {
9568       {
9569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9570       };
9571     }
9572   }
9573   jresult = result;
9574   return jresult;
9575 }
9576
9577
9578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9579   void * jresult ;
9580   Dali::Radian arg1 ;
9581   float arg2 ;
9582   Dali::Radian *argp1 ;
9583   Dali::Radian result;
9584
9585   argp1 = (Dali::Radian *)jarg1;
9586   if (!argp1) {
9587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9588     return 0;
9589   }
9590   arg1 = *argp1;
9591   arg2 = (float)jarg2;
9592   {
9593     try {
9594       result = Dali::operator *(arg1,arg2);
9595     } catch (std::out_of_range& e) {
9596       {
9597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9598       };
9599     } catch (std::exception& e) {
9600       {
9601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9602       };
9603     } catch (...) {
9604       {
9605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9606       };
9607     }
9608   }
9609   jresult = new Dali::Radian((const Dali::Radian &)result);
9610   return jresult;
9611 }
9612
9613
9614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9615   void * jresult ;
9616   Dali::Radian arg1 ;
9617   Dali::Radian *argp1 ;
9618   Dali::Radian result;
9619
9620   argp1 = (Dali::Radian *)jarg1;
9621   if (!argp1) {
9622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9623     return 0;
9624   }
9625   arg1 = *argp1;
9626   {
9627     try {
9628       result = Dali::operator -(arg1);
9629     } catch (std::out_of_range& e) {
9630       {
9631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9632       };
9633     } catch (std::exception& e) {
9634       {
9635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9636       };
9637     } catch (...) {
9638       {
9639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9640       };
9641     }
9642   }
9643   jresult = new Dali::Radian((const Dali::Radian &)result);
9644   return jresult;
9645 }
9646
9647
9648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9649   void * jresult ;
9650   Dali::Radian arg1 ;
9651   float arg2 ;
9652   float arg3 ;
9653   Dali::Radian *argp1 ;
9654   Dali::Radian result;
9655
9656   argp1 = (Dali::Radian *)jarg1;
9657   if (!argp1) {
9658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9659     return 0;
9660   }
9661   arg1 = *argp1;
9662   arg2 = (float)jarg2;
9663   arg3 = (float)jarg3;
9664   {
9665     try {
9666       result = Dali::Clamp(arg1,arg2,arg3);
9667     } catch (std::out_of_range& e) {
9668       {
9669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9670       };
9671     } catch (std::exception& e) {
9672       {
9673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9674       };
9675     } catch (...) {
9676       {
9677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9678       };
9679     }
9680   }
9681   jresult = new Dali::Radian((const Dali::Radian &)result);
9682   return jresult;
9683 }
9684
9685
9686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9687   void * jresult ;
9688   Dali::Quaternion *result = 0 ;
9689
9690   {
9691     try {
9692       result = (Dali::Quaternion *)new Dali::Quaternion();
9693     } catch (std::out_of_range& e) {
9694       {
9695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9696       };
9697     } catch (std::exception& e) {
9698       {
9699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9700       };
9701     } catch (...) {
9702       {
9703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9704       };
9705     }
9706   }
9707   jresult = (void *)result;
9708   return jresult;
9709 }
9710
9711
9712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9713   void * jresult ;
9714   Dali::Radian arg1 ;
9715   Dali::Vector3 *arg2 = 0 ;
9716   Dali::Radian *argp1 ;
9717   Dali::Quaternion *result = 0 ;
9718
9719   argp1 = (Dali::Radian *)jarg1;
9720   if (!argp1) {
9721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9722     return 0;
9723   }
9724   arg1 = *argp1;
9725   arg2 = (Dali::Vector3 *)jarg2;
9726   if (!arg2) {
9727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9728     return 0;
9729   }
9730   {
9731     try {
9732       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9733     } catch (std::out_of_range& e) {
9734       {
9735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9736       };
9737     } catch (std::exception& e) {
9738       {
9739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9740       };
9741     } catch (...) {
9742       {
9743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9744       };
9745     }
9746   }
9747   jresult = (void *)result;
9748   return jresult;
9749 }
9750
9751
9752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9753   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9754
9755   arg1 = (Dali::Quaternion *)jarg1;
9756   {
9757     try {
9758       delete arg1;
9759     } catch (std::out_of_range& e) {
9760       {
9761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9762       };
9763     } catch (std::exception& e) {
9764       {
9765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9766       };
9767     } catch (...) {
9768       {
9769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9770       };
9771     }
9772   }
9773 }
9774
9775
9776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9777   void * jresult ;
9778   Dali::Quaternion *result = 0 ;
9779
9780   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9781   jresult = (void *)result;
9782   return jresult;
9783 }
9784
9785
9786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9787   unsigned int jresult ;
9788   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9789   bool result;
9790
9791   arg1 = (Dali::Quaternion *)jarg1;
9792   {
9793     try {
9794       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9795     } catch (std::out_of_range& e) {
9796       {
9797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9798       };
9799     } catch (std::exception& e) {
9800       {
9801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9802       };
9803     } catch (...) {
9804       {
9805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9806       };
9807     }
9808   }
9809   jresult = result;
9810   return jresult;
9811 }
9812
9813
9814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9815   unsigned int jresult ;
9816   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9817   Dali::Vector3 *arg2 = 0 ;
9818   Dali::Radian *arg3 = 0 ;
9819   bool result;
9820
9821   arg1 = (Dali::Quaternion *)jarg1;
9822   arg2 = (Dali::Vector3 *)jarg2;
9823   if (!arg2) {
9824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9825     return 0;
9826   }
9827   arg3 = (Dali::Radian *)jarg3;
9828   if (!arg3) {
9829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9830     return 0;
9831   }
9832   {
9833     try {
9834       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9835     } catch (std::out_of_range& e) {
9836       {
9837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9838       };
9839     } catch (std::exception& e) {
9840       {
9841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9842       };
9843     } catch (...) {
9844       {
9845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9846       };
9847     }
9848   }
9849   jresult = result;
9850   return jresult;
9851 }
9852
9853
9854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9855   void * jresult ;
9856   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9857   Dali::Quaternion *arg2 = 0 ;
9858   Dali::Quaternion result;
9859
9860   arg1 = (Dali::Quaternion *)jarg1;
9861   arg2 = (Dali::Quaternion *)jarg2;
9862   if (!arg2) {
9863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9864     return 0;
9865   }
9866   {
9867     try {
9868       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9869     } catch (std::out_of_range& e) {
9870       {
9871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9872       };
9873     } catch (std::exception& e) {
9874       {
9875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9876       };
9877     } catch (...) {
9878       {
9879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9880       };
9881     }
9882   }
9883   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9884   return jresult;
9885 }
9886
9887
9888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9889   void * jresult ;
9890   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9891   Dali::Quaternion *arg2 = 0 ;
9892   Dali::Quaternion result;
9893
9894   arg1 = (Dali::Quaternion *)jarg1;
9895   arg2 = (Dali::Quaternion *)jarg2;
9896   if (!arg2) {
9897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9898     return 0;
9899   }
9900   {
9901     try {
9902       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
9903     } catch (std::out_of_range& e) {
9904       {
9905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9906       };
9907     } catch (std::exception& e) {
9908       {
9909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9910       };
9911     } catch (...) {
9912       {
9913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9914       };
9915     }
9916   }
9917   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9918   return jresult;
9919 }
9920
9921
9922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
9923   void * jresult ;
9924   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9925   Dali::Quaternion *arg2 = 0 ;
9926   Dali::Quaternion result;
9927
9928   arg1 = (Dali::Quaternion *)jarg1;
9929   arg2 = (Dali::Quaternion *)jarg2;
9930   if (!arg2) {
9931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9932     return 0;
9933   }
9934   {
9935     try {
9936       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
9937     } catch (std::out_of_range& e) {
9938       {
9939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9940       };
9941     } catch (std::exception& e) {
9942       {
9943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9944       };
9945     } catch (...) {
9946       {
9947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9948       };
9949     }
9950   }
9951   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9952   return jresult;
9953 }
9954
9955
9956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
9957   void * jresult ;
9958   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9959   Dali::Vector3 *arg2 = 0 ;
9960   Dali::Vector3 result;
9961
9962   arg1 = (Dali::Quaternion *)jarg1;
9963   arg2 = (Dali::Vector3 *)jarg2;
9964   if (!arg2) {
9965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9966     return 0;
9967   }
9968   {
9969     try {
9970       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
9971     } catch (std::out_of_range& e) {
9972       {
9973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9974       };
9975     } catch (std::exception& e) {
9976       {
9977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9978       };
9979     } catch (...) {
9980       {
9981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9982       };
9983     }
9984   }
9985   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
9986   return jresult;
9987 }
9988
9989
9990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
9991   void * jresult ;
9992   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9993   Dali::Quaternion *arg2 = 0 ;
9994   Dali::Quaternion result;
9995
9996   arg1 = (Dali::Quaternion *)jarg1;
9997   arg2 = (Dali::Quaternion *)jarg2;
9998   if (!arg2) {
9999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10000     return 0;
10001   }
10002   {
10003     try {
10004       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10005     } catch (std::out_of_range& e) {
10006       {
10007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10008       };
10009     } catch (std::exception& e) {
10010       {
10011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10012       };
10013     } catch (...) {
10014       {
10015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10016       };
10017     }
10018   }
10019   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10020   return jresult;
10021 }
10022
10023
10024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10025   void * jresult ;
10026   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10027   float arg2 ;
10028   Dali::Quaternion result;
10029
10030   arg1 = (Dali::Quaternion *)jarg1;
10031   arg2 = (float)jarg2;
10032   {
10033     try {
10034       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10035     } catch (std::out_of_range& e) {
10036       {
10037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10038       };
10039     } catch (std::exception& e) {
10040       {
10041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10042       };
10043     } catch (...) {
10044       {
10045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10046       };
10047     }
10048   }
10049   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10050   return jresult;
10051 }
10052
10053
10054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10055   void * jresult ;
10056   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10057   float arg2 ;
10058   Dali::Quaternion result;
10059
10060   arg1 = (Dali::Quaternion *)jarg1;
10061   arg2 = (float)jarg2;
10062   {
10063     try {
10064       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10065     } catch (std::out_of_range& e) {
10066       {
10067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10068       };
10069     } catch (std::exception& e) {
10070       {
10071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10072       };
10073     } catch (...) {
10074       {
10075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10076       };
10077     }
10078   }
10079   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10080   return jresult;
10081 }
10082
10083
10084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10085   void * jresult ;
10086   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10087   Dali::Quaternion result;
10088
10089   arg1 = (Dali::Quaternion *)jarg1;
10090   {
10091     try {
10092       result = ((Dali::Quaternion const *)arg1)->operator -();
10093     } catch (std::out_of_range& e) {
10094       {
10095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10096       };
10097     } catch (std::exception& e) {
10098       {
10099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10100       };
10101     } catch (...) {
10102       {
10103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10104       };
10105     }
10106   }
10107   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10108   return jresult;
10109 }
10110
10111
10112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10113   void * jresult ;
10114   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10115   Dali::Quaternion *arg2 = 0 ;
10116   Dali::Quaternion *result = 0 ;
10117
10118   arg1 = (Dali::Quaternion *)jarg1;
10119   arg2 = (Dali::Quaternion *)jarg2;
10120   if (!arg2) {
10121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10122     return 0;
10123   }
10124   {
10125     try {
10126       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10127     } catch (std::out_of_range& e) {
10128       {
10129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10130       };
10131     } catch (std::exception& e) {
10132       {
10133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10134       };
10135     } catch (...) {
10136       {
10137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10138       };
10139     }
10140   }
10141   jresult = (void *)result;
10142   return jresult;
10143 }
10144
10145
10146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10147   void * jresult ;
10148   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10149   Dali::Quaternion *arg2 = 0 ;
10150   Dali::Quaternion *result = 0 ;
10151
10152   arg1 = (Dali::Quaternion *)jarg1;
10153   arg2 = (Dali::Quaternion *)jarg2;
10154   if (!arg2) {
10155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10156     return 0;
10157   }
10158   {
10159     try {
10160       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10161     } catch (std::out_of_range& e) {
10162       {
10163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10164       };
10165     } catch (std::exception& e) {
10166       {
10167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10168       };
10169     } catch (...) {
10170       {
10171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10172       };
10173     }
10174   }
10175   jresult = (void *)result;
10176   return jresult;
10177 }
10178
10179
10180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10181   void * jresult ;
10182   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10183   Dali::Quaternion *arg2 = 0 ;
10184   Dali::Quaternion *result = 0 ;
10185
10186   arg1 = (Dali::Quaternion *)jarg1;
10187   arg2 = (Dali::Quaternion *)jarg2;
10188   if (!arg2) {
10189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10190     return 0;
10191   }
10192   {
10193     try {
10194       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10195     } catch (std::out_of_range& e) {
10196       {
10197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10198       };
10199     } catch (std::exception& e) {
10200       {
10201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10202       };
10203     } catch (...) {
10204       {
10205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10206       };
10207     }
10208   }
10209   jresult = (void *)result;
10210   return jresult;
10211 }
10212
10213
10214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10215   void * jresult ;
10216   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10217   float arg2 ;
10218   Dali::Quaternion *result = 0 ;
10219
10220   arg1 = (Dali::Quaternion *)jarg1;
10221   arg2 = (float)jarg2;
10222   {
10223     try {
10224       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10225     } catch (std::out_of_range& e) {
10226       {
10227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10228       };
10229     } catch (std::exception& e) {
10230       {
10231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10232       };
10233     } catch (...) {
10234       {
10235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10236       };
10237     }
10238   }
10239   jresult = (void *)result;
10240   return jresult;
10241 }
10242
10243
10244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10245   void * jresult ;
10246   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10247   float arg2 ;
10248   Dali::Quaternion *result = 0 ;
10249
10250   arg1 = (Dali::Quaternion *)jarg1;
10251   arg2 = (float)jarg2;
10252   {
10253     try {
10254       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10255     } catch (std::out_of_range& e) {
10256       {
10257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10258       };
10259     } catch (std::exception& e) {
10260       {
10261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10262       };
10263     } catch (...) {
10264       {
10265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10266       };
10267     }
10268   }
10269   jresult = (void *)result;
10270   return jresult;
10271 }
10272
10273
10274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10275   unsigned int jresult ;
10276   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10277   Dali::Quaternion *arg2 = 0 ;
10278   bool result;
10279
10280   arg1 = (Dali::Quaternion *)jarg1;
10281   arg2 = (Dali::Quaternion *)jarg2;
10282   if (!arg2) {
10283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10284     return 0;
10285   }
10286   {
10287     try {
10288       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10289     } catch (std::out_of_range& e) {
10290       {
10291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10292       };
10293     } catch (std::exception& e) {
10294       {
10295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10296       };
10297     } catch (...) {
10298       {
10299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10300       };
10301     }
10302   }
10303   jresult = result;
10304   return jresult;
10305 }
10306
10307
10308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10309   unsigned int jresult ;
10310   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10311   Dali::Quaternion *arg2 = 0 ;
10312   bool result;
10313
10314   arg1 = (Dali::Quaternion *)jarg1;
10315   arg2 = (Dali::Quaternion *)jarg2;
10316   if (!arg2) {
10317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10318     return 0;
10319   }
10320   {
10321     try {
10322       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10323     } catch (std::out_of_range& e) {
10324       {
10325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10326       };
10327     } catch (std::exception& e) {
10328       {
10329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10330       };
10331     } catch (...) {
10332       {
10333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10334       };
10335     }
10336   }
10337   jresult = result;
10338   return jresult;
10339 }
10340
10341
10342 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10343   float jresult ;
10344   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10345   float result;
10346
10347   arg1 = (Dali::Quaternion *)jarg1;
10348   {
10349     try {
10350       result = (float)((Dali::Quaternion const *)arg1)->Length();
10351     } catch (std::out_of_range& e) {
10352       {
10353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10354       };
10355     } catch (std::exception& e) {
10356       {
10357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10358       };
10359     } catch (...) {
10360       {
10361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10362       };
10363     }
10364   }
10365   jresult = result;
10366   return jresult;
10367 }
10368
10369
10370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10371   float jresult ;
10372   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10373   float result;
10374
10375   arg1 = (Dali::Quaternion *)jarg1;
10376   {
10377     try {
10378       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10379     } catch (std::out_of_range& e) {
10380       {
10381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10382       };
10383     } catch (std::exception& e) {
10384       {
10385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10386       };
10387     } catch (...) {
10388       {
10389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10390       };
10391     }
10392   }
10393   jresult = result;
10394   return jresult;
10395 }
10396
10397
10398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10399   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10400
10401   arg1 = (Dali::Quaternion *)jarg1;
10402   {
10403     try {
10404       (arg1)->Normalize();
10405     } catch (std::out_of_range& e) {
10406       {
10407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10408       };
10409     } catch (std::exception& e) {
10410       {
10411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10412       };
10413     } catch (...) {
10414       {
10415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10416       };
10417     }
10418   }
10419 }
10420
10421
10422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10423   void * jresult ;
10424   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10425   Dali::Quaternion result;
10426
10427   arg1 = (Dali::Quaternion *)jarg1;
10428   {
10429     try {
10430       result = ((Dali::Quaternion const *)arg1)->Normalized();
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 = new Dali::Quaternion((const Dali::Quaternion &)result);
10446   return jresult;
10447 }
10448
10449
10450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10451   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10452
10453   arg1 = (Dali::Quaternion *)jarg1;
10454   {
10455     try {
10456       (arg1)->Conjugate();
10457     } catch (std::out_of_range& e) {
10458       {
10459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10460       };
10461     } catch (std::exception& e) {
10462       {
10463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10464       };
10465     } catch (...) {
10466       {
10467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10468       };
10469     }
10470   }
10471 }
10472
10473
10474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10475   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10476
10477   arg1 = (Dali::Quaternion *)jarg1;
10478   {
10479     try {
10480       (arg1)->Invert();
10481     } catch (std::out_of_range& e) {
10482       {
10483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10484       };
10485     } catch (std::exception& e) {
10486       {
10487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10488       };
10489     } catch (...) {
10490       {
10491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10492       };
10493     }
10494   }
10495 }
10496
10497
10498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10499   void * jresult ;
10500   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10501   Dali::Quaternion result;
10502
10503   arg1 = (Dali::Quaternion *)jarg1;
10504   {
10505     try {
10506       result = ((Dali::Quaternion const *)arg1)->Log();
10507     } catch (std::out_of_range& e) {
10508       {
10509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10510       };
10511     } catch (std::exception& e) {
10512       {
10513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10514       };
10515     } catch (...) {
10516       {
10517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10518       };
10519     }
10520   }
10521   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10522   return jresult;
10523 }
10524
10525
10526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10527   void * jresult ;
10528   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10529   Dali::Quaternion result;
10530
10531   arg1 = (Dali::Quaternion *)jarg1;
10532   {
10533     try {
10534       result = ((Dali::Quaternion const *)arg1)->Exp();
10535     } catch (std::out_of_range& e) {
10536       {
10537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10538       };
10539     } catch (std::exception& e) {
10540       {
10541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10542       };
10543     } catch (...) {
10544       {
10545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10546       };
10547     }
10548   }
10549   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10550   return jresult;
10551 }
10552
10553
10554 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10555   float jresult ;
10556   Dali::Quaternion *arg1 = 0 ;
10557   Dali::Quaternion *arg2 = 0 ;
10558   float result;
10559
10560   arg1 = (Dali::Quaternion *)jarg1;
10561   if (!arg1) {
10562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10563     return 0;
10564   }
10565   arg2 = (Dali::Quaternion *)jarg2;
10566   if (!arg2) {
10567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10568     return 0;
10569   }
10570   {
10571     try {
10572       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10573     } catch (std::out_of_range& e) {
10574       {
10575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10576       };
10577     } catch (std::exception& e) {
10578       {
10579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10580       };
10581     } catch (...) {
10582       {
10583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10584       };
10585     }
10586   }
10587   jresult = result;
10588   return jresult;
10589 }
10590
10591
10592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10593   void * jresult ;
10594   Dali::Quaternion *arg1 = 0 ;
10595   Dali::Quaternion *arg2 = 0 ;
10596   float arg3 ;
10597   Dali::Quaternion result;
10598
10599   arg1 = (Dali::Quaternion *)jarg1;
10600   if (!arg1) {
10601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10602     return 0;
10603   }
10604   arg2 = (Dali::Quaternion *)jarg2;
10605   if (!arg2) {
10606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10607     return 0;
10608   }
10609   arg3 = (float)jarg3;
10610   {
10611     try {
10612       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10613     } catch (std::out_of_range& e) {
10614       {
10615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10616       };
10617     } catch (std::exception& e) {
10618       {
10619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10620       };
10621     } catch (...) {
10622       {
10623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10624       };
10625     }
10626   }
10627   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10628   return jresult;
10629 }
10630
10631
10632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10633   void * jresult ;
10634   Dali::Quaternion *arg1 = 0 ;
10635   Dali::Quaternion *arg2 = 0 ;
10636   float arg3 ;
10637   Dali::Quaternion result;
10638
10639   arg1 = (Dali::Quaternion *)jarg1;
10640   if (!arg1) {
10641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10642     return 0;
10643   }
10644   arg2 = (Dali::Quaternion *)jarg2;
10645   if (!arg2) {
10646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10647     return 0;
10648   }
10649   arg3 = (float)jarg3;
10650   {
10651     try {
10652       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
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 = new Dali::Quaternion((const Dali::Quaternion &)result);
10668   return jresult;
10669 }
10670
10671
10672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(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::SlerpNoInvert((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_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10713   void * jresult ;
10714   Dali::Quaternion *arg1 = 0 ;
10715   Dali::Quaternion *arg2 = 0 ;
10716   Dali::Quaternion *arg3 = 0 ;
10717   Dali::Quaternion *arg4 = 0 ;
10718   float arg5 ;
10719   Dali::Quaternion result;
10720
10721   arg1 = (Dali::Quaternion *)jarg1;
10722   if (!arg1) {
10723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10724     return 0;
10725   }
10726   arg2 = (Dali::Quaternion *)jarg2;
10727   if (!arg2) {
10728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10729     return 0;
10730   }
10731   arg3 = (Dali::Quaternion *)jarg3;
10732   if (!arg3) {
10733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10734     return 0;
10735   }
10736   arg4 = (Dali::Quaternion *)jarg4;
10737   if (!arg4) {
10738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10739     return 0;
10740   }
10741   arg5 = (float)jarg5;
10742   {
10743     try {
10744       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10745     } catch (std::out_of_range& e) {
10746       {
10747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10748       };
10749     } catch (std::exception& e) {
10750       {
10751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10752       };
10753     } catch (...) {
10754       {
10755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10756       };
10757     }
10758   }
10759   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10760   return jresult;
10761 }
10762
10763
10764 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10765   float jresult ;
10766   Dali::Quaternion *arg1 = 0 ;
10767   Dali::Quaternion *arg2 = 0 ;
10768   float result;
10769
10770   arg1 = (Dali::Quaternion *)jarg1;
10771   if (!arg1) {
10772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10773     return 0;
10774   }
10775   arg2 = (Dali::Quaternion *)jarg2;
10776   if (!arg2) {
10777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10778     return 0;
10779   }
10780   {
10781     try {
10782       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10783     } catch (std::out_of_range& e) {
10784       {
10785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10786       };
10787     } catch (std::exception& e) {
10788       {
10789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10790       };
10791     } catch (...) {
10792       {
10793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10794       };
10795     }
10796   }
10797   jresult = result;
10798   return jresult;
10799 }
10800
10801
10802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10803   void * jresult ;
10804   Dali::Matrix *result = 0 ;
10805
10806   {
10807     try {
10808       result = (Dali::Matrix *)new Dali::Matrix();
10809     } catch (std::out_of_range& e) {
10810       {
10811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10812       };
10813     } catch (std::exception& e) {
10814       {
10815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10816       };
10817     } catch (...) {
10818       {
10819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10820       };
10821     }
10822   }
10823   jresult = (void *)result;
10824   return jresult;
10825 }
10826
10827
10828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10829   void * jresult ;
10830   bool arg1 ;
10831   Dali::Matrix *result = 0 ;
10832
10833   arg1 = jarg1 ? true : false;
10834   {
10835     try {
10836       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10837     } catch (std::out_of_range& e) {
10838       {
10839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10840       };
10841     } catch (std::exception& e) {
10842       {
10843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10844       };
10845     } catch (...) {
10846       {
10847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10848       };
10849     }
10850   }
10851   jresult = (void *)result;
10852   return jresult;
10853 }
10854
10855
10856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10857   void * jresult ;
10858   float *arg1 = (float *) 0 ;
10859   Dali::Matrix *result = 0 ;
10860
10861   arg1 = jarg1;
10862   {
10863     try {
10864       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10865     } catch (std::out_of_range& e) {
10866       {
10867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10868       };
10869     } catch (std::exception& e) {
10870       {
10871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10872       };
10873     } catch (...) {
10874       {
10875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10876       };
10877     }
10878   }
10879   jresult = (void *)result;
10880
10881
10882   return jresult;
10883 }
10884
10885
10886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10887   void * jresult ;
10888   Dali::Quaternion *arg1 = 0 ;
10889   Dali::Matrix *result = 0 ;
10890
10891   arg1 = (Dali::Quaternion *)jarg1;
10892   if (!arg1) {
10893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10894     return 0;
10895   }
10896   {
10897     try {
10898       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
10899     } catch (std::out_of_range& e) {
10900       {
10901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10902       };
10903     } catch (std::exception& e) {
10904       {
10905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10906       };
10907     } catch (...) {
10908       {
10909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10910       };
10911     }
10912   }
10913   jresult = (void *)result;
10914   return jresult;
10915 }
10916
10917
10918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
10919   void * jresult ;
10920   Dali::Matrix *arg1 = 0 ;
10921   Dali::Matrix *result = 0 ;
10922
10923   arg1 = (Dali::Matrix *)jarg1;
10924   if (!arg1) {
10925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10926     return 0;
10927   }
10928   {
10929     try {
10930       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
10931     } catch (std::out_of_range& e) {
10932       {
10933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10934       };
10935     } catch (std::exception& e) {
10936       {
10937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10938       };
10939     } catch (...) {
10940       {
10941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10942       };
10943     }
10944   }
10945   jresult = (void *)result;
10946   return jresult;
10947 }
10948
10949
10950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
10951   void * jresult ;
10952   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10953   Dali::Matrix *arg2 = 0 ;
10954   Dali::Matrix *result = 0 ;
10955
10956   arg1 = (Dali::Matrix *)jarg1;
10957   arg2 = (Dali::Matrix *)jarg2;
10958   if (!arg2) {
10959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10960     return 0;
10961   }
10962   {
10963     try {
10964       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
10965     } catch (std::out_of_range& e) {
10966       {
10967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10968       };
10969     } catch (std::exception& e) {
10970       {
10971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10972       };
10973     } catch (...) {
10974       {
10975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10976       };
10977     }
10978   }
10979   jresult = (void *)result;
10980   return jresult;
10981 }
10982
10983
10984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
10985   void * jresult ;
10986   Dali::Matrix *result = 0 ;
10987
10988   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
10989   jresult = (void *)result;
10990   return jresult;
10991 }
10992
10993
10994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
10995   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10996
10997   arg1 = (Dali::Matrix *)jarg1;
10998   {
10999     try {
11000       (arg1)->SetIdentity();
11001     } catch (std::out_of_range& e) {
11002       {
11003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11004       };
11005     } catch (std::exception& e) {
11006       {
11007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11008       };
11009     } catch (...) {
11010       {
11011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11012       };
11013     }
11014   }
11015 }
11016
11017
11018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11019   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11020   Dali::Vector3 *arg2 = 0 ;
11021
11022   arg1 = (Dali::Matrix *)jarg1;
11023   arg2 = (Dali::Vector3 *)jarg2;
11024   if (!arg2) {
11025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11026     return ;
11027   }
11028   {
11029     try {
11030       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11031     } catch (std::out_of_range& e) {
11032       {
11033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11034       };
11035     } catch (std::exception& e) {
11036       {
11037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11038       };
11039     } catch (...) {
11040       {
11041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11042       };
11043     }
11044   }
11045 }
11046
11047
11048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11049   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11050   Dali::Matrix *arg2 = 0 ;
11051
11052   arg1 = (Dali::Matrix *)jarg1;
11053   arg2 = (Dali::Matrix *)jarg2;
11054   if (!arg2) {
11055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11056     return ;
11057   }
11058   {
11059     try {
11060       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11061     } catch (std::out_of_range& e) {
11062       {
11063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11064       };
11065     } catch (std::exception& e) {
11066       {
11067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11068       };
11069     } catch (...) {
11070       {
11071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11072       };
11073     }
11074   }
11075 }
11076
11077
11078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11079   unsigned int jresult ;
11080   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11081   bool result;
11082
11083   arg1 = (Dali::Matrix *)jarg1;
11084   {
11085     try {
11086       result = (bool)(arg1)->Invert();
11087     } catch (std::out_of_range& e) {
11088       {
11089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11090       };
11091     } catch (std::exception& e) {
11092       {
11093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11094       };
11095     } catch (...) {
11096       {
11097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11098       };
11099     }
11100   }
11101   jresult = result;
11102   return jresult;
11103 }
11104
11105
11106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11107   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11108
11109   arg1 = (Dali::Matrix *)jarg1;
11110   {
11111     try {
11112       (arg1)->Transpose();
11113     } catch (std::out_of_range& e) {
11114       {
11115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11116       };
11117     } catch (std::exception& e) {
11118       {
11119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11120       };
11121     } catch (...) {
11122       {
11123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11124       };
11125     }
11126   }
11127 }
11128
11129
11130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11131   void * jresult ;
11132   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11133   Dali::Vector3 result;
11134
11135   arg1 = (Dali::Matrix *)jarg1;
11136   {
11137     try {
11138       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11139     } catch (std::out_of_range& e) {
11140       {
11141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11142       };
11143     } catch (std::exception& e) {
11144       {
11145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11146       };
11147     } catch (...) {
11148       {
11149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11150       };
11151     }
11152   }
11153   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11154   return jresult;
11155 }
11156
11157
11158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11159   void * jresult ;
11160   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11161   Dali::Vector3 result;
11162
11163   arg1 = (Dali::Matrix *)jarg1;
11164   {
11165     try {
11166       result = ((Dali::Matrix const *)arg1)->GetYAxis();
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 = new Dali::Vector3((const Dali::Vector3 &)result);
11182   return jresult;
11183 }
11184
11185
11186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11187   void * jresult ;
11188   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11189   Dali::Vector3 result;
11190
11191   arg1 = (Dali::Matrix *)jarg1;
11192   {
11193     try {
11194       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11195     } catch (std::out_of_range& e) {
11196       {
11197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11198       };
11199     } catch (std::exception& e) {
11200       {
11201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11202       };
11203     } catch (...) {
11204       {
11205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11206       };
11207     }
11208   }
11209   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11210   return jresult;
11211 }
11212
11213
11214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11215   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11216   Dali::Vector3 *arg2 = 0 ;
11217
11218   arg1 = (Dali::Matrix *)jarg1;
11219   arg2 = (Dali::Vector3 *)jarg2;
11220   if (!arg2) {
11221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11222     return ;
11223   }
11224   {
11225     try {
11226       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11227     } catch (std::out_of_range& e) {
11228       {
11229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11230       };
11231     } catch (std::exception& e) {
11232       {
11233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11234       };
11235     } catch (...) {
11236       {
11237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11238       };
11239     }
11240   }
11241 }
11242
11243
11244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11245   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11246   Dali::Vector3 *arg2 = 0 ;
11247
11248   arg1 = (Dali::Matrix *)jarg1;
11249   arg2 = (Dali::Vector3 *)jarg2;
11250   if (!arg2) {
11251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11252     return ;
11253   }
11254   {
11255     try {
11256       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11257     } catch (std::out_of_range& e) {
11258       {
11259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11260       };
11261     } catch (std::exception& e) {
11262       {
11263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11264       };
11265     } catch (...) {
11266       {
11267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11268       };
11269     }
11270   }
11271 }
11272
11273
11274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11275   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11276   Dali::Vector3 *arg2 = 0 ;
11277
11278   arg1 = (Dali::Matrix *)jarg1;
11279   arg2 = (Dali::Vector3 *)jarg2;
11280   if (!arg2) {
11281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11282     return ;
11283   }
11284   {
11285     try {
11286       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11287     } catch (std::out_of_range& e) {
11288       {
11289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11290       };
11291     } catch (std::exception& e) {
11292       {
11293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11294       };
11295     } catch (...) {
11296       {
11297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11298       };
11299     }
11300   }
11301 }
11302
11303
11304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11305   void * jresult ;
11306   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11307   Dali::Vector4 *result = 0 ;
11308
11309   arg1 = (Dali::Matrix *)jarg1;
11310   {
11311     try {
11312       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11313     } catch (std::out_of_range& e) {
11314       {
11315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11316       };
11317     } catch (std::exception& e) {
11318       {
11319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11320       };
11321     } catch (...) {
11322       {
11323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11324       };
11325     }
11326   }
11327   jresult = (void *)result;
11328   return jresult;
11329 }
11330
11331
11332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11333   void * jresult ;
11334   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11335   Dali::Vector3 *result = 0 ;
11336
11337   arg1 = (Dali::Matrix *)jarg1;
11338   {
11339     try {
11340       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11341     } catch (std::out_of_range& e) {
11342       {
11343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11344       };
11345     } catch (std::exception& e) {
11346       {
11347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11348       };
11349     } catch (...) {
11350       {
11351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11352       };
11353     }
11354   }
11355   jresult = (void *)result;
11356   return jresult;
11357 }
11358
11359
11360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11361   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11362   Dali::Vector4 *arg2 = 0 ;
11363
11364   arg1 = (Dali::Matrix *)jarg1;
11365   arg2 = (Dali::Vector4 *)jarg2;
11366   if (!arg2) {
11367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11368     return ;
11369   }
11370   {
11371     try {
11372       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11373     } catch (std::out_of_range& e) {
11374       {
11375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11376       };
11377     } catch (std::exception& e) {
11378       {
11379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11380       };
11381     } catch (...) {
11382       {
11383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11384       };
11385     }
11386   }
11387 }
11388
11389
11390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11391   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11392   Dali::Vector3 *arg2 = 0 ;
11393
11394   arg1 = (Dali::Matrix *)jarg1;
11395   arg2 = (Dali::Vector3 *)jarg2;
11396   if (!arg2) {
11397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11398     return ;
11399   }
11400   {
11401     try {
11402       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11403     } catch (std::out_of_range& e) {
11404       {
11405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11406       };
11407     } catch (std::exception& e) {
11408       {
11409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11410       };
11411     } catch (...) {
11412       {
11413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11414       };
11415     }
11416   }
11417 }
11418
11419
11420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11421   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11422
11423   arg1 = (Dali::Matrix *)jarg1;
11424   {
11425     try {
11426       (arg1)->OrthoNormalize();
11427     } catch (std::out_of_range& e) {
11428       {
11429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11430       };
11431     } catch (std::exception& e) {
11432       {
11433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11434       };
11435     } catch (...) {
11436       {
11437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11438       };
11439     }
11440   }
11441 }
11442
11443
11444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11445   void * jresult ;
11446   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11447   float *result = 0 ;
11448
11449   arg1 = (Dali::Matrix *)jarg1;
11450   {
11451     try {
11452       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11453     } catch (std::out_of_range& e) {
11454       {
11455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11456       };
11457     } catch (std::exception& e) {
11458       {
11459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11460       };
11461     } catch (...) {
11462       {
11463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11464       };
11465     }
11466   }
11467   jresult = (void *)result;
11468   return jresult;
11469 }
11470
11471
11472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11473   Dali::Matrix *arg1 = 0 ;
11474   Dali::Matrix *arg2 = 0 ;
11475   Dali::Matrix *arg3 = 0 ;
11476
11477   arg1 = (Dali::Matrix *)jarg1;
11478   if (!arg1) {
11479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11480     return ;
11481   }
11482   arg2 = (Dali::Matrix *)jarg2;
11483   if (!arg2) {
11484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11485     return ;
11486   }
11487   arg3 = (Dali::Matrix *)jarg3;
11488   if (!arg3) {
11489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11490     return ;
11491   }
11492   {
11493     try {
11494       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11495     } catch (std::out_of_range& e) {
11496       {
11497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11498       };
11499     } catch (std::exception& e) {
11500       {
11501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11502       };
11503     } catch (...) {
11504       {
11505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11506       };
11507     }
11508   }
11509 }
11510
11511
11512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11513   Dali::Matrix *arg1 = 0 ;
11514   Dali::Matrix *arg2 = 0 ;
11515   Dali::Quaternion *arg3 = 0 ;
11516
11517   arg1 = (Dali::Matrix *)jarg1;
11518   if (!arg1) {
11519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11520     return ;
11521   }
11522   arg2 = (Dali::Matrix *)jarg2;
11523   if (!arg2) {
11524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11525     return ;
11526   }
11527   arg3 = (Dali::Quaternion *)jarg3;
11528   if (!arg3) {
11529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11530     return ;
11531   }
11532   {
11533     try {
11534       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11535     } catch (std::out_of_range& e) {
11536       {
11537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11538       };
11539     } catch (std::exception& e) {
11540       {
11541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11542       };
11543     } catch (...) {
11544       {
11545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11546       };
11547     }
11548   }
11549 }
11550
11551
11552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11553   void * jresult ;
11554   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11555   Dali::Vector4 *arg2 = 0 ;
11556   Dali::Vector4 result;
11557
11558   arg1 = (Dali::Matrix *)jarg1;
11559   arg2 = (Dali::Vector4 *)jarg2;
11560   if (!arg2) {
11561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11562     return 0;
11563   }
11564   {
11565     try {
11566       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11567     } catch (std::out_of_range& e) {
11568       {
11569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11570       };
11571     } catch (std::exception& e) {
11572       {
11573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11574       };
11575     } catch (...) {
11576       {
11577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11578       };
11579     }
11580   }
11581   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11582   return jresult;
11583 }
11584
11585
11586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11587   unsigned int jresult ;
11588   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11589   Dali::Matrix *arg2 = 0 ;
11590   bool result;
11591
11592   arg1 = (Dali::Matrix *)jarg1;
11593   arg2 = (Dali::Matrix *)jarg2;
11594   if (!arg2) {
11595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11596     return 0;
11597   }
11598   {
11599     try {
11600       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11601     } catch (std::out_of_range& e) {
11602       {
11603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11604       };
11605     } catch (std::exception& e) {
11606       {
11607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11608       };
11609     } catch (...) {
11610       {
11611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11612       };
11613     }
11614   }
11615   jresult = result;
11616   return jresult;
11617 }
11618
11619
11620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11621   unsigned int jresult ;
11622   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11623   Dali::Matrix *arg2 = 0 ;
11624   bool result;
11625
11626   arg1 = (Dali::Matrix *)jarg1;
11627   arg2 = (Dali::Matrix *)jarg2;
11628   if (!arg2) {
11629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11630     return 0;
11631   }
11632   {
11633     try {
11634       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11635     } catch (std::out_of_range& e) {
11636       {
11637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11638       };
11639     } catch (std::exception& e) {
11640       {
11641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11642       };
11643     } catch (...) {
11644       {
11645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11646       };
11647     }
11648   }
11649   jresult = result;
11650   return jresult;
11651 }
11652
11653
11654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11655   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11656   Dali::Vector3 *arg2 = 0 ;
11657   Dali::Quaternion *arg3 = 0 ;
11658   Dali::Vector3 *arg4 = 0 ;
11659
11660   arg1 = (Dali::Matrix *)jarg1;
11661   arg2 = (Dali::Vector3 *)jarg2;
11662   if (!arg2) {
11663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11664     return ;
11665   }
11666   arg3 = (Dali::Quaternion *)jarg3;
11667   if (!arg3) {
11668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11669     return ;
11670   }
11671   arg4 = (Dali::Vector3 *)jarg4;
11672   if (!arg4) {
11673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11674     return ;
11675   }
11676   {
11677     try {
11678       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11679     } catch (std::out_of_range& e) {
11680       {
11681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11682       };
11683     } catch (std::exception& e) {
11684       {
11685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11686       };
11687     } catch (...) {
11688       {
11689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11690       };
11691     }
11692   }
11693 }
11694
11695
11696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11697   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11698   Dali::Vector3 *arg2 = 0 ;
11699   Dali::Quaternion *arg3 = 0 ;
11700   Dali::Vector3 *arg4 = 0 ;
11701
11702   arg1 = (Dali::Matrix *)jarg1;
11703   arg2 = (Dali::Vector3 *)jarg2;
11704   if (!arg2) {
11705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11706     return ;
11707   }
11708   arg3 = (Dali::Quaternion *)jarg3;
11709   if (!arg3) {
11710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11711     return ;
11712   }
11713   arg4 = (Dali::Vector3 *)jarg4;
11714   if (!arg4) {
11715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11716     return ;
11717   }
11718   {
11719     try {
11720       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11721     } catch (std::out_of_range& e) {
11722       {
11723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11724       };
11725     } catch (std::exception& e) {
11726       {
11727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11728       };
11729     } catch (...) {
11730       {
11731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11732       };
11733     }
11734   }
11735 }
11736
11737
11738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11739   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11740   Dali::Vector3 *arg2 = 0 ;
11741   Dali::Vector3 *arg3 = 0 ;
11742   Dali::Vector3 *arg4 = 0 ;
11743   Dali::Vector3 *arg5 = 0 ;
11744
11745   arg1 = (Dali::Matrix *)jarg1;
11746   arg2 = (Dali::Vector3 *)jarg2;
11747   if (!arg2) {
11748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11749     return ;
11750   }
11751   arg3 = (Dali::Vector3 *)jarg3;
11752   if (!arg3) {
11753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11754     return ;
11755   }
11756   arg4 = (Dali::Vector3 *)jarg4;
11757   if (!arg4) {
11758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11759     return ;
11760   }
11761   arg5 = (Dali::Vector3 *)jarg5;
11762   if (!arg5) {
11763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11764     return ;
11765   }
11766   {
11767     try {
11768       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11769     } catch (std::out_of_range& e) {
11770       {
11771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11772       };
11773     } catch (std::exception& e) {
11774       {
11775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11776       };
11777     } catch (...) {
11778       {
11779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11780       };
11781     }
11782   }
11783 }
11784
11785
11786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11787   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11788   Dali::Vector3 *arg2 = 0 ;
11789   Dali::Quaternion *arg3 = 0 ;
11790   Dali::Vector3 *arg4 = 0 ;
11791
11792   arg1 = (Dali::Matrix *)jarg1;
11793   arg2 = (Dali::Vector3 *)jarg2;
11794   if (!arg2) {
11795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11796     return ;
11797   }
11798   arg3 = (Dali::Quaternion *)jarg3;
11799   if (!arg3) {
11800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11801     return ;
11802   }
11803   arg4 = (Dali::Vector3 *)jarg4;
11804   if (!arg4) {
11805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11806     return ;
11807   }
11808   {
11809     try {
11810       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11811     } catch (std::out_of_range& e) {
11812       {
11813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11814       };
11815     } catch (std::exception& e) {
11816       {
11817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11818       };
11819     } catch (...) {
11820       {
11821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11822       };
11823     }
11824   }
11825 }
11826
11827
11828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11829   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11830
11831   arg1 = (Dali::Matrix *)jarg1;
11832   {
11833     try {
11834       delete arg1;
11835     } catch (std::out_of_range& e) {
11836       {
11837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11838       };
11839     } catch (std::exception& e) {
11840       {
11841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11842       };
11843     } catch (...) {
11844       {
11845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11846       };
11847     }
11848   }
11849 }
11850
11851
11852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11853   void * jresult ;
11854   Dali::Matrix3 *result = 0 ;
11855
11856   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11857   jresult = (void *)result;
11858   return jresult;
11859 }
11860
11861
11862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11863   void * jresult ;
11864   Dali::Matrix3 *result = 0 ;
11865
11866   {
11867     try {
11868       result = (Dali::Matrix3 *)new Dali::Matrix3();
11869     } catch (std::out_of_range& e) {
11870       {
11871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11872       };
11873     } catch (std::exception& e) {
11874       {
11875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11876       };
11877     } catch (...) {
11878       {
11879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11880       };
11881     }
11882   }
11883   jresult = (void *)result;
11884   return jresult;
11885 }
11886
11887
11888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11889   void * jresult ;
11890   Dali::Matrix3 *arg1 = 0 ;
11891   Dali::Matrix3 *result = 0 ;
11892
11893   arg1 = (Dali::Matrix3 *)jarg1;
11894   if (!arg1) {
11895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11896     return 0;
11897   }
11898   {
11899     try {
11900       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
11901     } catch (std::out_of_range& e) {
11902       {
11903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11904       };
11905     } catch (std::exception& e) {
11906       {
11907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11908       };
11909     } catch (...) {
11910       {
11911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11912       };
11913     }
11914   }
11915   jresult = (void *)result;
11916   return jresult;
11917 }
11918
11919
11920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
11921   void * jresult ;
11922   Dali::Matrix *arg1 = 0 ;
11923   Dali::Matrix3 *result = 0 ;
11924
11925   arg1 = (Dali::Matrix *)jarg1;
11926   if (!arg1) {
11927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11928     return 0;
11929   }
11930   {
11931     try {
11932       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
11933     } catch (std::out_of_range& e) {
11934       {
11935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11936       };
11937     } catch (std::exception& e) {
11938       {
11939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11940       };
11941     } catch (...) {
11942       {
11943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11944       };
11945     }
11946   }
11947   jresult = (void *)result;
11948   return jresult;
11949 }
11950
11951
11952 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) {
11953   void * jresult ;
11954   float arg1 ;
11955   float arg2 ;
11956   float arg3 ;
11957   float arg4 ;
11958   float arg5 ;
11959   float arg6 ;
11960   float arg7 ;
11961   float arg8 ;
11962   float arg9 ;
11963   Dali::Matrix3 *result = 0 ;
11964
11965   arg1 = (float)jarg1;
11966   arg2 = (float)jarg2;
11967   arg3 = (float)jarg3;
11968   arg4 = (float)jarg4;
11969   arg5 = (float)jarg5;
11970   arg6 = (float)jarg6;
11971   arg7 = (float)jarg7;
11972   arg8 = (float)jarg8;
11973   arg9 = (float)jarg9;
11974   {
11975     try {
11976       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
11977     } catch (std::out_of_range& e) {
11978       {
11979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11980       };
11981     } catch (std::exception& e) {
11982       {
11983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11984       };
11985     } catch (...) {
11986       {
11987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11988       };
11989     }
11990   }
11991   jresult = (void *)result;
11992   return jresult;
11993 }
11994
11995
11996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
11997   void * jresult ;
11998   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
11999   Dali::Matrix3 *arg2 = 0 ;
12000   Dali::Matrix3 *result = 0 ;
12001
12002   arg1 = (Dali::Matrix3 *)jarg1;
12003   arg2 = (Dali::Matrix3 *)jarg2;
12004   if (!arg2) {
12005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12006     return 0;
12007   }
12008   {
12009     try {
12010       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12011     } catch (std::out_of_range& e) {
12012       {
12013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12014       };
12015     } catch (std::exception& e) {
12016       {
12017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12018       };
12019     } catch (...) {
12020       {
12021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12022       };
12023     }
12024   }
12025   jresult = (void *)result;
12026   return jresult;
12027 }
12028
12029
12030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12031   void * jresult ;
12032   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12033   Dali::Matrix *arg2 = 0 ;
12034   Dali::Matrix3 *result = 0 ;
12035
12036   arg1 = (Dali::Matrix3 *)jarg1;
12037   arg2 = (Dali::Matrix *)jarg2;
12038   if (!arg2) {
12039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12040     return 0;
12041   }
12042   {
12043     try {
12044       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12045     } catch (std::out_of_range& e) {
12046       {
12047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12048       };
12049     } catch (std::exception& e) {
12050       {
12051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12052       };
12053     } catch (...) {
12054       {
12055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12056       };
12057     }
12058   }
12059   jresult = (void *)result;
12060   return jresult;
12061 }
12062
12063
12064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12065   unsigned int jresult ;
12066   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12067   Dali::Matrix3 *arg2 = 0 ;
12068   bool result;
12069
12070   arg1 = (Dali::Matrix3 *)jarg1;
12071   arg2 = (Dali::Matrix3 *)jarg2;
12072   if (!arg2) {
12073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12074     return 0;
12075   }
12076   {
12077     try {
12078       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12079     } catch (std::out_of_range& e) {
12080       {
12081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12082       };
12083     } catch (std::exception& e) {
12084       {
12085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12086       };
12087     } catch (...) {
12088       {
12089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12090       };
12091     }
12092   }
12093   jresult = result;
12094   return jresult;
12095 }
12096
12097
12098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12099   unsigned int jresult ;
12100   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12101   Dali::Matrix3 *arg2 = 0 ;
12102   bool result;
12103
12104   arg1 = (Dali::Matrix3 *)jarg1;
12105   arg2 = (Dali::Matrix3 *)jarg2;
12106   if (!arg2) {
12107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12108     return 0;
12109   }
12110   {
12111     try {
12112       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12113     } catch (std::out_of_range& e) {
12114       {
12115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12116       };
12117     } catch (std::exception& e) {
12118       {
12119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12120       };
12121     } catch (...) {
12122       {
12123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12124       };
12125     }
12126   }
12127   jresult = result;
12128   return jresult;
12129 }
12130
12131
12132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12133   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12134
12135   arg1 = (Dali::Matrix3 *)jarg1;
12136   {
12137     try {
12138       delete arg1;
12139     } catch (std::out_of_range& e) {
12140       {
12141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12142       };
12143     } catch (std::exception& e) {
12144       {
12145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12146       };
12147     } catch (...) {
12148       {
12149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12150       };
12151     }
12152   }
12153 }
12154
12155
12156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12157   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12158
12159   arg1 = (Dali::Matrix3 *)jarg1;
12160   {
12161     try {
12162       (arg1)->SetIdentity();
12163     } catch (std::out_of_range& e) {
12164       {
12165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12166       };
12167     } catch (std::exception& e) {
12168       {
12169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12170       };
12171     } catch (...) {
12172       {
12173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12174       };
12175     }
12176   }
12177 }
12178
12179
12180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12181   void * jresult ;
12182   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12183   float *result = 0 ;
12184
12185   arg1 = (Dali::Matrix3 *)jarg1;
12186   {
12187     try {
12188       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12189     } catch (std::out_of_range& e) {
12190       {
12191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12192       };
12193     } catch (std::exception& e) {
12194       {
12195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12196       };
12197     } catch (...) {
12198       {
12199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12200       };
12201     }
12202   }
12203   jresult = (void *)result;
12204   return jresult;
12205 }
12206
12207
12208 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12209   unsigned int jresult ;
12210   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12211   bool result;
12212
12213   arg1 = (Dali::Matrix3 *)jarg1;
12214   {
12215     try {
12216       result = (bool)(arg1)->Invert();
12217     } catch (std::out_of_range& e) {
12218       {
12219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12220       };
12221     } catch (std::exception& e) {
12222       {
12223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12224       };
12225     } catch (...) {
12226       {
12227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12228       };
12229     }
12230   }
12231   jresult = result;
12232   return jresult;
12233 }
12234
12235
12236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12237   unsigned int jresult ;
12238   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12239   bool result;
12240
12241   arg1 = (Dali::Matrix3 *)jarg1;
12242   {
12243     try {
12244       result = (bool)(arg1)->Transpose();
12245     } catch (std::out_of_range& e) {
12246       {
12247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12248       };
12249     } catch (std::exception& e) {
12250       {
12251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12252       };
12253     } catch (...) {
12254       {
12255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12256       };
12257     }
12258   }
12259   jresult = result;
12260   return jresult;
12261 }
12262
12263
12264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12265   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12266   float arg2 ;
12267
12268   arg1 = (Dali::Matrix3 *)jarg1;
12269   arg2 = (float)jarg2;
12270   {
12271     try {
12272       (arg1)->Scale(arg2);
12273     } catch (std::out_of_range& e) {
12274       {
12275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12276       };
12277     } catch (std::exception& e) {
12278       {
12279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12280       };
12281     } catch (...) {
12282       {
12283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12284       };
12285     }
12286   }
12287 }
12288
12289
12290 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12291   float jresult ;
12292   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12293   float result;
12294
12295   arg1 = (Dali::Matrix3 *)jarg1;
12296   {
12297     try {
12298       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12299     } catch (std::out_of_range& e) {
12300       {
12301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12302       };
12303     } catch (std::exception& e) {
12304       {
12305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12306       };
12307     } catch (...) {
12308       {
12309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12310       };
12311     }
12312   }
12313   jresult = result;
12314   return jresult;
12315 }
12316
12317
12318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12319   unsigned int jresult ;
12320   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12321   bool result;
12322
12323   arg1 = (Dali::Matrix3 *)jarg1;
12324   {
12325     try {
12326       result = (bool)(arg1)->ScaledInverseTranspose();
12327     } catch (std::out_of_range& e) {
12328       {
12329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12330       };
12331     } catch (std::exception& e) {
12332       {
12333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12334       };
12335     } catch (...) {
12336       {
12337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12338       };
12339     }
12340   }
12341   jresult = result;
12342   return jresult;
12343 }
12344
12345
12346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12347   Dali::Matrix3 *arg1 = 0 ;
12348   Dali::Matrix3 *arg2 = 0 ;
12349   Dali::Matrix3 *arg3 = 0 ;
12350
12351   arg1 = (Dali::Matrix3 *)jarg1;
12352   if (!arg1) {
12353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12354     return ;
12355   }
12356   arg2 = (Dali::Matrix3 *)jarg2;
12357   if (!arg2) {
12358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12359     return ;
12360   }
12361   arg3 = (Dali::Matrix3 *)jarg3;
12362   if (!arg3) {
12363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12364     return ;
12365   }
12366   {
12367     try {
12368       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12369     } catch (std::out_of_range& e) {
12370       {
12371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12372       };
12373     } catch (std::exception& e) {
12374       {
12375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12376       };
12377     } catch (...) {
12378       {
12379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12380       };
12381     }
12382   }
12383 }
12384
12385
12386 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12387   float jresult ;
12388   float arg1 ;
12389   float arg2 ;
12390   float result;
12391
12392   arg1 = (float)jarg1;
12393   arg2 = (float)jarg2;
12394   {
12395     try {
12396       result = (float)Dali::Random::Range(arg1,arg2);
12397     } catch (std::out_of_range& e) {
12398       {
12399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12400       };
12401     } catch (std::exception& e) {
12402       {
12403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12404       };
12405     } catch (...) {
12406       {
12407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12408       };
12409     }
12410   }
12411   jresult = result;
12412   return jresult;
12413 }
12414
12415
12416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12417   void * jresult ;
12418   Dali::Vector4 result;
12419
12420   {
12421     try {
12422       result = Dali::Random::Axis();
12423     } catch (std::out_of_range& e) {
12424       {
12425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12426       };
12427     } catch (std::exception& e) {
12428       {
12429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12430       };
12431     } catch (...) {
12432       {
12433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12434       };
12435     }
12436   }
12437   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12438   return jresult;
12439 }
12440
12441
12442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12443   void * jresult ;
12444   Dali::AngleAxis *result = 0 ;
12445
12446   {
12447     try {
12448       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12449     } catch (std::out_of_range& e) {
12450       {
12451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12452       };
12453     } catch (std::exception& e) {
12454       {
12455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12456       };
12457     } catch (...) {
12458       {
12459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12460       };
12461     }
12462   }
12463   jresult = (void *)result;
12464   return jresult;
12465 }
12466
12467
12468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12469   void * jresult ;
12470   Dali::Radian arg1 ;
12471   Dali::Vector3 *arg2 = 0 ;
12472   Dali::Radian *argp1 ;
12473   Dali::AngleAxis *result = 0 ;
12474
12475   argp1 = (Dali::Radian *)jarg1;
12476   if (!argp1) {
12477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12478     return 0;
12479   }
12480   arg1 = *argp1;
12481   arg2 = (Dali::Vector3 *)jarg2;
12482   if (!arg2) {
12483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12484     return 0;
12485   }
12486   {
12487     try {
12488       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12489     } catch (std::out_of_range& e) {
12490       {
12491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12492       };
12493     } catch (std::exception& e) {
12494       {
12495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12496       };
12497     } catch (...) {
12498       {
12499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12500       };
12501     }
12502   }
12503   jresult = (void *)result;
12504   return jresult;
12505 }
12506
12507
12508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12509   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12510   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12511
12512   arg1 = (Dali::AngleAxis *)jarg1;
12513   arg2 = (Dali::Radian *)jarg2;
12514   if (arg1) (arg1)->angle = *arg2;
12515 }
12516
12517
12518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12519   void * jresult ;
12520   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12521   Dali::Radian *result = 0 ;
12522
12523   arg1 = (Dali::AngleAxis *)jarg1;
12524   result = (Dali::Radian *)& ((arg1)->angle);
12525   jresult = (void *)result;
12526   return jresult;
12527 }
12528
12529
12530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12531   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12532   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12533
12534   arg1 = (Dali::AngleAxis *)jarg1;
12535   arg2 = (Dali::Vector3 *)jarg2;
12536   if (arg1) (arg1)->axis = *arg2;
12537 }
12538
12539
12540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12541   void * jresult ;
12542   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12543   Dali::Vector3 *result = 0 ;
12544
12545   arg1 = (Dali::AngleAxis *)jarg1;
12546   result = (Dali::Vector3 *)& ((arg1)->axis);
12547   jresult = (void *)result;
12548   return jresult;
12549 }
12550
12551
12552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12553   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12554
12555   arg1 = (Dali::AngleAxis *)jarg1;
12556   {
12557     try {
12558       delete arg1;
12559     } catch (std::out_of_range& e) {
12560       {
12561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12562       };
12563     } catch (std::exception& e) {
12564       {
12565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12566       };
12567     } catch (...) {
12568       {
12569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12570       };
12571     }
12572   }
12573 }
12574
12575
12576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12577   unsigned int jresult ;
12578   Dali::AngleAxis *arg1 = 0 ;
12579   Dali::AngleAxis *arg2 = 0 ;
12580   bool result;
12581
12582   arg1 = (Dali::AngleAxis *)jarg1;
12583   if (!arg1) {
12584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12585     return 0;
12586   }
12587   arg2 = (Dali::AngleAxis *)jarg2;
12588   if (!arg2) {
12589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12590     return 0;
12591   }
12592   {
12593     try {
12594       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12595     } catch (std::out_of_range& e) {
12596       {
12597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12598       };
12599     } catch (std::exception& e) {
12600       {
12601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12602       };
12603     } catch (...) {
12604       {
12605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12606       };
12607     }
12608   }
12609   jresult = result;
12610   return jresult;
12611 }
12612
12613
12614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12615   unsigned int jresult ;
12616   unsigned int arg1 ;
12617   unsigned int result;
12618
12619   arg1 = (unsigned int)jarg1;
12620   {
12621     try {
12622       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12623     } catch (std::out_of_range& e) {
12624       {
12625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12626       };
12627     } catch (std::exception& e) {
12628       {
12629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12630       };
12631     } catch (...) {
12632       {
12633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12634       };
12635     }
12636   }
12637   jresult = result;
12638   return jresult;
12639 }
12640
12641
12642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12643   unsigned int jresult ;
12644   unsigned int arg1 ;
12645   bool result;
12646
12647   arg1 = (unsigned int)jarg1;
12648   {
12649     try {
12650       result = (bool)Dali::IsPowerOfTwo(arg1);
12651     } catch (std::out_of_range& e) {
12652       {
12653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12654       };
12655     } catch (std::exception& e) {
12656       {
12657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12658       };
12659     } catch (...) {
12660       {
12661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12662       };
12663     }
12664   }
12665   jresult = result;
12666   return jresult;
12667 }
12668
12669
12670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12671   float jresult ;
12672   float arg1 ;
12673   float arg2 ;
12674   float result;
12675
12676   arg1 = (float)jarg1;
12677   arg2 = (float)jarg2;
12678   {
12679     try {
12680       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12681     } catch (std::out_of_range& e) {
12682       {
12683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12684       };
12685     } catch (std::exception& e) {
12686       {
12687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12688       };
12689     } catch (...) {
12690       {
12691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12692       };
12693     }
12694   }
12695   jresult = result;
12696   return jresult;
12697 }
12698
12699
12700 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12701   unsigned int jresult ;
12702   float arg1 ;
12703   bool result;
12704
12705   arg1 = (float)jarg1;
12706   {
12707     try {
12708       result = (bool)Dali::EqualsZero(arg1);
12709     } catch (std::out_of_range& e) {
12710       {
12711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12712       };
12713     } catch (std::exception& e) {
12714       {
12715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12716       };
12717     } catch (...) {
12718       {
12719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12720       };
12721     }
12722   }
12723   jresult = result;
12724   return jresult;
12725 }
12726
12727
12728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12729   unsigned int jresult ;
12730   float arg1 ;
12731   float arg2 ;
12732   bool result;
12733
12734   arg1 = (float)jarg1;
12735   arg2 = (float)jarg2;
12736   {
12737     try {
12738       result = (bool)Dali::Equals(arg1,arg2);
12739     } catch (std::out_of_range& e) {
12740       {
12741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12742       };
12743     } catch (std::exception& e) {
12744       {
12745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12746       };
12747     } catch (...) {
12748       {
12749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12750       };
12751     }
12752   }
12753   jresult = result;
12754   return jresult;
12755 }
12756
12757
12758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12759   unsigned int jresult ;
12760   float arg1 ;
12761   float arg2 ;
12762   float arg3 ;
12763   bool result;
12764
12765   arg1 = (float)jarg1;
12766   arg2 = (float)jarg2;
12767   arg3 = (float)jarg3;
12768   {
12769     try {
12770       result = (bool)Dali::Equals(arg1,arg2,arg3);
12771     } catch (std::out_of_range& e) {
12772       {
12773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12774       };
12775     } catch (std::exception& e) {
12776       {
12777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12778       };
12779     } catch (...) {
12780       {
12781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12782       };
12783     }
12784   }
12785   jresult = result;
12786   return jresult;
12787 }
12788
12789
12790 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12791   float jresult ;
12792   float arg1 ;
12793   int arg2 ;
12794   float result;
12795
12796   arg1 = (float)jarg1;
12797   arg2 = (int)jarg2;
12798   {
12799     try {
12800       result = (float)Dali::Round(arg1,arg2);
12801     } catch (std::out_of_range& e) {
12802       {
12803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12804       };
12805     } catch (std::exception& e) {
12806       {
12807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12808       };
12809     } catch (...) {
12810       {
12811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12812       };
12813     }
12814   }
12815   jresult = result;
12816   return jresult;
12817 }
12818
12819
12820 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12821   float jresult ;
12822   float arg1 ;
12823   float arg2 ;
12824   float arg3 ;
12825   float result;
12826
12827   arg1 = (float)jarg1;
12828   arg2 = (float)jarg2;
12829   arg3 = (float)jarg3;
12830   {
12831     try {
12832       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12833     } catch (std::out_of_range& e) {
12834       {
12835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12836       };
12837     } catch (std::exception& e) {
12838       {
12839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12840       };
12841     } catch (...) {
12842       {
12843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12844       };
12845     }
12846   }
12847   jresult = result;
12848   return jresult;
12849 }
12850
12851
12852 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12853   float jresult ;
12854   float arg1 ;
12855   float arg2 ;
12856   float arg3 ;
12857   float arg4 ;
12858   float result;
12859
12860   arg1 = (float)jarg1;
12861   arg2 = (float)jarg2;
12862   arg3 = (float)jarg3;
12863   arg4 = (float)jarg4;
12864   {
12865     try {
12866       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12867     } catch (std::out_of_range& e) {
12868       {
12869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12870       };
12871     } catch (std::exception& e) {
12872       {
12873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12874       };
12875     } catch (...) {
12876       {
12877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12878       };
12879     }
12880   }
12881   jresult = result;
12882   return jresult;
12883 }
12884
12885
12886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12887   int jresult ;
12888   int result;
12889
12890   result = (int)(int)Dali::Property::INVALID_INDEX;
12891   jresult = result;
12892   return jresult;
12893 }
12894
12895
12896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12897   int jresult ;
12898   int result;
12899
12900   result = (int)(int)Dali::Property::INVALID_KEY;
12901   jresult = result;
12902   return jresult;
12903 }
12904
12905
12906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
12907   int jresult ;
12908   int result;
12909
12910   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
12911   jresult = result;
12912   return jresult;
12913 }
12914
12915
12916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
12917   void * jresult ;
12918   Dali::Handle *arg1 = 0 ;
12919   Dali::Property::Index arg2 ;
12920   Dali::Property *result = 0 ;
12921
12922   arg1 = (Dali::Handle *)jarg1;
12923   if (!arg1) {
12924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12925     return 0;
12926   }
12927   arg2 = (Dali::Property::Index)jarg2;
12928   {
12929     try {
12930       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
12931     } catch (std::out_of_range& e) {
12932       {
12933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12934       };
12935     } catch (std::exception& e) {
12936       {
12937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12938       };
12939     } catch (...) {
12940       {
12941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12942       };
12943     }
12944   }
12945   jresult = (void *)result;
12946   return jresult;
12947 }
12948
12949
12950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
12951   void * jresult ;
12952   Dali::Handle *arg1 = 0 ;
12953   Dali::Property::Index arg2 ;
12954   int arg3 ;
12955   Dali::Property *result = 0 ;
12956
12957   arg1 = (Dali::Handle *)jarg1;
12958   if (!arg1) {
12959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12960     return 0;
12961   }
12962   arg2 = (Dali::Property::Index)jarg2;
12963   arg3 = (int)jarg3;
12964   {
12965     try {
12966       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
12967     } catch (std::out_of_range& e) {
12968       {
12969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12970       };
12971     } catch (std::exception& e) {
12972       {
12973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12974       };
12975     } catch (...) {
12976       {
12977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12978       };
12979     }
12980   }
12981   jresult = (void *)result;
12982   return jresult;
12983 }
12984
12985
12986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
12987   void * jresult ;
12988   Dali::Handle *arg1 = 0 ;
12989   std::string *arg2 = 0 ;
12990   Dali::Property *result = 0 ;
12991
12992   arg1 = (Dali::Handle *)jarg1;
12993   if (!arg1) {
12994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12995     return 0;
12996   }
12997   if (!jarg2) {
12998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12999     return 0;
13000   }
13001   std::string arg2_str(jarg2);
13002   arg2 = &arg2_str;
13003   {
13004     try {
13005       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13006     } catch (std::out_of_range& e) {
13007       {
13008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13009       };
13010     } catch (std::exception& e) {
13011       {
13012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13013       };
13014     } catch (...) {
13015       {
13016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13017       };
13018     }
13019   }
13020   jresult = (void *)result;
13021
13022   //argout typemap for const std::string&
13023
13024   return jresult;
13025 }
13026
13027
13028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13029   void * jresult ;
13030   Dali::Handle *arg1 = 0 ;
13031   std::string *arg2 = 0 ;
13032   int arg3 ;
13033   Dali::Property *result = 0 ;
13034
13035   arg1 = (Dali::Handle *)jarg1;
13036   if (!arg1) {
13037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13038     return 0;
13039   }
13040   if (!jarg2) {
13041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13042     return 0;
13043   }
13044   std::string arg2_str(jarg2);
13045   arg2 = &arg2_str;
13046   arg3 = (int)jarg3;
13047   {
13048     try {
13049       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13050     } catch (std::out_of_range& e) {
13051       {
13052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13053       };
13054     } catch (std::exception& e) {
13055       {
13056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13057       };
13058     } catch (...) {
13059       {
13060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13061       };
13062     }
13063   }
13064   jresult = (void *)result;
13065
13066   //argout typemap for const std::string&
13067
13068   return jresult;
13069 }
13070
13071
13072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13073   Dali::Property *arg1 = (Dali::Property *) 0 ;
13074
13075   arg1 = (Dali::Property *)jarg1;
13076   {
13077     try {
13078       delete arg1;
13079     } catch (std::out_of_range& e) {
13080       {
13081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13082       };
13083     } catch (std::exception& e) {
13084       {
13085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13086       };
13087     } catch (...) {
13088       {
13089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13090       };
13091     }
13092   }
13093 }
13094
13095
13096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13097   Dali::Property *arg1 = (Dali::Property *) 0 ;
13098   Dali::Handle *arg2 = 0 ;
13099
13100   arg1 = (Dali::Property *)jarg1;
13101   arg2 = (Dali::Handle *)jarg2;
13102   if (!arg2) {
13103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13104     return ;
13105   }
13106   if (arg1) (arg1)->object = *arg2;
13107 }
13108
13109
13110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13111   void * jresult ;
13112   Dali::Property *arg1 = (Dali::Property *) 0 ;
13113   Dali::Handle *result = 0 ;
13114
13115   arg1 = (Dali::Property *)jarg1;
13116   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13117   jresult = (void *)result;
13118   return jresult;
13119 }
13120
13121
13122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13123   Dali::Property *arg1 = (Dali::Property *) 0 ;
13124   Dali::Property::Index arg2 ;
13125
13126   arg1 = (Dali::Property *)jarg1;
13127   arg2 = (Dali::Property::Index)jarg2;
13128   if (arg1) (arg1)->propertyIndex = arg2;
13129 }
13130
13131
13132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13133   int jresult ;
13134   Dali::Property *arg1 = (Dali::Property *) 0 ;
13135   Dali::Property::Index result;
13136
13137   arg1 = (Dali::Property *)jarg1;
13138   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13139   jresult = result;
13140   return jresult;
13141 }
13142
13143
13144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13145   Dali::Property *arg1 = (Dali::Property *) 0 ;
13146   int arg2 ;
13147
13148   arg1 = (Dali::Property *)jarg1;
13149   arg2 = (int)jarg2;
13150   if (arg1) (arg1)->componentIndex = arg2;
13151 }
13152
13153
13154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13155   int jresult ;
13156   Dali::Property *arg1 = (Dali::Property *) 0 ;
13157   int result;
13158
13159   arg1 = (Dali::Property *)jarg1;
13160   result = (int) ((arg1)->componentIndex);
13161   jresult = result;
13162   return jresult;
13163 }
13164
13165
13166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13167   void * jresult ;
13168   Dali::Property::Array *result = 0 ;
13169
13170   {
13171     try {
13172       result = (Dali::Property::Array *)new Dali::Property::Array();
13173     } catch (std::out_of_range& e) {
13174       {
13175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13176       };
13177     } catch (std::exception& e) {
13178       {
13179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13180       };
13181     } catch (...) {
13182       {
13183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13184       };
13185     }
13186   }
13187   jresult = (void *)result;
13188   return jresult;
13189 }
13190
13191
13192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13193   void * jresult ;
13194   Dali::Property::Array *arg1 = 0 ;
13195   Dali::Property::Array *result = 0 ;
13196
13197   arg1 = (Dali::Property::Array *)jarg1;
13198   if (!arg1) {
13199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13200     return 0;
13201   }
13202   {
13203     try {
13204       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13205     } catch (std::out_of_range& e) {
13206       {
13207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13208       };
13209     } catch (std::exception& e) {
13210       {
13211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13212       };
13213     } catch (...) {
13214       {
13215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13216       };
13217     }
13218   }
13219   jresult = (void *)result;
13220   return jresult;
13221 }
13222
13223
13224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13225   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13226
13227   arg1 = (Dali::Property::Array *)jarg1;
13228   {
13229     try {
13230       delete arg1;
13231     } catch (std::out_of_range& e) {
13232       {
13233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13234       };
13235     } catch (std::exception& e) {
13236       {
13237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13238       };
13239     } catch (...) {
13240       {
13241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13242       };
13243     }
13244   }
13245 }
13246
13247
13248 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13249   unsigned long jresult ;
13250   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13251   Dali::Property::Array::SizeType result;
13252
13253   arg1 = (Dali::Property::Array *)jarg1;
13254   {
13255     try {
13256       result = ((Dali::Property::Array const *)arg1)->Size();
13257     } catch (std::out_of_range& e) {
13258       {
13259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13260       };
13261     } catch (std::exception& e) {
13262       {
13263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13264       };
13265     } catch (...) {
13266       {
13267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13268       };
13269     }
13270   }
13271   jresult = (unsigned long)result;
13272   return jresult;
13273 }
13274
13275
13276 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13277   unsigned long jresult ;
13278   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13279   Dali::Property::Array::SizeType result;
13280
13281   arg1 = (Dali::Property::Array *)jarg1;
13282   {
13283     try {
13284       result = ((Dali::Property::Array const *)arg1)->Count();
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 = (unsigned long)result;
13300   return jresult;
13301 }
13302
13303
13304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13305   unsigned int jresult ;
13306   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13307   bool result;
13308
13309   arg1 = (Dali::Property::Array *)jarg1;
13310   {
13311     try {
13312       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13313     } catch (std::out_of_range& e) {
13314       {
13315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13316       };
13317     } catch (std::exception& e) {
13318       {
13319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13320       };
13321     } catch (...) {
13322       {
13323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13324       };
13325     }
13326   }
13327   jresult = result;
13328   return jresult;
13329 }
13330
13331
13332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13333   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13334
13335   arg1 = (Dali::Property::Array *)jarg1;
13336   {
13337     try {
13338       (arg1)->Clear();
13339     } catch (std::out_of_range& e) {
13340       {
13341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13342       };
13343     } catch (std::exception& e) {
13344       {
13345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13346       };
13347     } catch (...) {
13348       {
13349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13350       };
13351     }
13352   }
13353 }
13354
13355
13356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13357   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13358   Dali::Property::Array::SizeType arg2 ;
13359
13360   arg1 = (Dali::Property::Array *)jarg1;
13361   arg2 = (Dali::Property::Array::SizeType)jarg2;
13362   {
13363     try {
13364       (arg1)->Reserve(arg2);
13365     } catch (std::out_of_range& e) {
13366       {
13367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13368       };
13369     } catch (std::exception& e) {
13370       {
13371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13372       };
13373     } catch (...) {
13374       {
13375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13376       };
13377     }
13378   }
13379 }
13380
13381
13382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13383   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13384   Dali::Property::Array::SizeType arg2 ;
13385
13386   arg1 = (Dali::Property::Array *)jarg1;
13387   arg2 = (Dali::Property::Array::SizeType)jarg2;
13388   {
13389     try {
13390       (arg1)->Resize(arg2);
13391     } catch (std::out_of_range& e) {
13392       {
13393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13394       };
13395     } catch (std::exception& e) {
13396       {
13397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13398       };
13399     } catch (...) {
13400       {
13401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13402       };
13403     }
13404   }
13405 }
13406
13407
13408 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13409   unsigned long jresult ;
13410   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13411   Dali::Property::Array::SizeType result;
13412
13413   arg1 = (Dali::Property::Array *)jarg1;
13414   {
13415     try {
13416       result = (arg1)->Capacity();
13417     } catch (std::out_of_range& e) {
13418       {
13419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13420       };
13421     } catch (std::exception& e) {
13422       {
13423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13424       };
13425     } catch (...) {
13426       {
13427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13428       };
13429     }
13430   }
13431   jresult = (unsigned long)result;
13432   return jresult;
13433 }
13434
13435
13436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13437   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13438   Dali::Property::Value *arg2 = 0 ;
13439
13440   arg1 = (Dali::Property::Array *)jarg1;
13441   arg2 = (Dali::Property::Value *)jarg2;
13442   if (!arg2) {
13443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13444     return ;
13445   }
13446   {
13447     try {
13448       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13449     } catch (std::out_of_range& e) {
13450       {
13451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13452       };
13453     } catch (std::exception& e) {
13454       {
13455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13456       };
13457     } catch (...) {
13458       {
13459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13460       };
13461     }
13462   }
13463 }
13464
13465
13466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13467   void * jresult ;
13468   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13469   Dali::Property::Value *arg2 = 0 ;
13470   Dali::Property::Array *result = 0 ;
13471
13472   arg1 = (Dali::Property::Array *)jarg1;
13473   arg2 = (Dali::Property::Value *)jarg2;
13474   if (!arg2) {
13475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13476     return 0;
13477   }
13478   {
13479     try {
13480       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13481     } catch (std::out_of_range& e) {
13482       {
13483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13484       };
13485     } catch (std::exception& e) {
13486       {
13487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13488       };
13489     } catch (...) {
13490       {
13491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13492       };
13493     }
13494   }
13495   jresult = (void *)result;
13496   return jresult;
13497 }
13498
13499
13500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13501   void * jresult ;
13502   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13503   Dali::Property::Array::SizeType arg2 ;
13504   Dali::Property::Value *result = 0 ;
13505
13506   arg1 = (Dali::Property::Array *)jarg1;
13507   arg2 = (Dali::Property::Array::SizeType)jarg2;
13508   {
13509     try {
13510       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13511     } catch (std::out_of_range& e) {
13512       {
13513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13514       };
13515     } catch (std::exception& e) {
13516       {
13517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13518       };
13519     } catch (...) {
13520       {
13521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13522       };
13523     }
13524   }
13525   jresult = (void *)result;
13526   return jresult;
13527 }
13528
13529
13530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13531   void * jresult ;
13532   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13533   Dali::Property::Array::SizeType arg2 ;
13534   Dali::Property::Value *result = 0 ;
13535
13536   arg1 = (Dali::Property::Array *)jarg1;
13537   arg2 = (Dali::Property::Array::SizeType)jarg2;
13538   {
13539     try {
13540       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13541     } catch (std::out_of_range& e) {
13542       {
13543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13544       };
13545     } catch (std::exception& e) {
13546       {
13547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13548       };
13549     } catch (...) {
13550       {
13551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13552       };
13553     }
13554   }
13555   jresult = (void *)result;
13556   return jresult;
13557 }
13558
13559
13560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13561   void * jresult ;
13562   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13563   Dali::Property::Array *arg2 = 0 ;
13564   Dali::Property::Array *result = 0 ;
13565
13566   arg1 = (Dali::Property::Array *)jarg1;
13567   arg2 = (Dali::Property::Array *)jarg2;
13568   if (!arg2) {
13569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13570     return 0;
13571   }
13572   {
13573     try {
13574       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13575     } catch (std::out_of_range& e) {
13576       {
13577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13578       };
13579     } catch (std::exception& e) {
13580       {
13581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13582       };
13583     } catch (...) {
13584       {
13585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13586       };
13587     }
13588   }
13589   jresult = (void *)result;
13590   return jresult;
13591 }
13592
13593
13594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13595   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13596   enum Dali::Property::Key::Type arg2 ;
13597
13598   arg1 = (Dali::Property::Key *)jarg1;
13599   arg2 = (enum Dali::Property::Key::Type)jarg2;
13600   if (arg1) (arg1)->type = arg2;
13601 }
13602
13603
13604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13605   int jresult ;
13606   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13607   enum Dali::Property::Key::Type result;
13608
13609   arg1 = (Dali::Property::Key *)jarg1;
13610   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13611   jresult = (int)result;
13612   return jresult;
13613 }
13614
13615
13616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13617   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13618   Dali::Property::Index arg2 ;
13619
13620   arg1 = (Dali::Property::Key *)jarg1;
13621   arg2 = (Dali::Property::Index)jarg2;
13622   if (arg1) (arg1)->indexKey = arg2;
13623 }
13624
13625
13626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13627   int jresult ;
13628   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13629   Dali::Property::Index result;
13630
13631   arg1 = (Dali::Property::Key *)jarg1;
13632   result = (Dali::Property::Index) ((arg1)->indexKey);
13633   jresult = result;
13634   return jresult;
13635 }
13636
13637
13638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13639   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13640   std::string *arg2 = 0 ;
13641
13642   arg1 = (Dali::Property::Key *)jarg1;
13643   if (!jarg2) {
13644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13645     return ;
13646   }
13647   std::string arg2_str(jarg2);
13648   arg2 = &arg2_str;
13649   if (arg1) (arg1)->stringKey = *arg2;
13650
13651   //argout typemap for const std::string&
13652
13653 }
13654
13655
13656 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13657   char * jresult ;
13658   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13659   std::string *result = 0 ;
13660
13661   arg1 = (Dali::Property::Key *)jarg1;
13662   result = (std::string *) & ((arg1)->stringKey);
13663   jresult = SWIG_csharp_string_callback(result->c_str());
13664   return jresult;
13665 }
13666
13667
13668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13669   void * jresult ;
13670   std::string *arg1 = 0 ;
13671   Dali::Property::Key *result = 0 ;
13672
13673   if (!jarg1) {
13674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13675     return 0;
13676   }
13677   std::string arg1_str(jarg1);
13678   arg1 = &arg1_str;
13679   {
13680     try {
13681       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13682     } catch (std::out_of_range& e) {
13683       {
13684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13685       };
13686     } catch (std::exception& e) {
13687       {
13688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13689       };
13690     } catch (...) {
13691       {
13692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13693       };
13694     }
13695   }
13696   jresult = (void *)result;
13697
13698   //argout typemap for const std::string&
13699
13700   return jresult;
13701 }
13702
13703
13704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13705   void * jresult ;
13706   Dali::Property::Index arg1 ;
13707   Dali::Property::Key *result = 0 ;
13708
13709   arg1 = (Dali::Property::Index)jarg1;
13710   {
13711     try {
13712       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13713     } catch (std::out_of_range& e) {
13714       {
13715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13716       };
13717     } catch (std::exception& e) {
13718       {
13719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13720       };
13721     } catch (...) {
13722       {
13723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13724       };
13725     }
13726   }
13727   jresult = (void *)result;
13728   return jresult;
13729 }
13730
13731
13732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13733   unsigned int jresult ;
13734   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13735   std::string *arg2 = 0 ;
13736   bool result;
13737
13738   arg1 = (Dali::Property::Key *)jarg1;
13739   if (!jarg2) {
13740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13741     return 0;
13742   }
13743   std::string arg2_str(jarg2);
13744   arg2 = &arg2_str;
13745   {
13746     try {
13747       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13748     } catch (std::out_of_range& e) {
13749       {
13750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13751       };
13752     } catch (std::exception& e) {
13753       {
13754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13755       };
13756     } catch (...) {
13757       {
13758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13759       };
13760     }
13761   }
13762   jresult = result;
13763
13764   //argout typemap for const std::string&
13765
13766   return jresult;
13767 }
13768
13769
13770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13771   unsigned int jresult ;
13772   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13773   Dali::Property::Index arg2 ;
13774   bool result;
13775
13776   arg1 = (Dali::Property::Key *)jarg1;
13777   arg2 = (Dali::Property::Index)jarg2;
13778   {
13779     try {
13780       result = (bool)(arg1)->operator ==(arg2);
13781     } catch (std::out_of_range& e) {
13782       {
13783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13784       };
13785     } catch (std::exception& e) {
13786       {
13787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13788       };
13789     } catch (...) {
13790       {
13791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13792       };
13793     }
13794   }
13795   jresult = result;
13796   return jresult;
13797 }
13798
13799
13800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13801   unsigned int jresult ;
13802   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13803   Dali::Property::Key *arg2 = 0 ;
13804   bool result;
13805
13806   arg1 = (Dali::Property::Key *)jarg1;
13807   arg2 = (Dali::Property::Key *)jarg2;
13808   if (!arg2) {
13809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13810     return 0;
13811   }
13812   {
13813     try {
13814       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13815     } catch (std::out_of_range& e) {
13816       {
13817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13818       };
13819     } catch (std::exception& e) {
13820       {
13821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13822       };
13823     } catch (...) {
13824       {
13825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13826       };
13827     }
13828   }
13829   jresult = result;
13830   return jresult;
13831 }
13832
13833
13834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13835   unsigned int jresult ;
13836   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13837   std::string *arg2 = 0 ;
13838   bool result;
13839
13840   arg1 = (Dali::Property::Key *)jarg1;
13841   if (!jarg2) {
13842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13843     return 0;
13844   }
13845   std::string arg2_str(jarg2);
13846   arg2 = &arg2_str;
13847   {
13848     try {
13849       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13850     } catch (std::out_of_range& e) {
13851       {
13852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13853       };
13854     } catch (std::exception& e) {
13855       {
13856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13857       };
13858     } catch (...) {
13859       {
13860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13861       };
13862     }
13863   }
13864   jresult = result;
13865
13866   //argout typemap for const std::string&
13867
13868   return jresult;
13869 }
13870
13871
13872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13873   unsigned int jresult ;
13874   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13875   Dali::Property::Index arg2 ;
13876   bool result;
13877
13878   arg1 = (Dali::Property::Key *)jarg1;
13879   arg2 = (Dali::Property::Index)jarg2;
13880   {
13881     try {
13882       result = (bool)(arg1)->operator !=(arg2);
13883     } catch (std::out_of_range& e) {
13884       {
13885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13886       };
13887     } catch (std::exception& e) {
13888       {
13889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13890       };
13891     } catch (...) {
13892       {
13893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13894       };
13895     }
13896   }
13897   jresult = result;
13898   return jresult;
13899 }
13900
13901
13902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
13903   unsigned int jresult ;
13904   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13905   Dali::Property::Key *arg2 = 0 ;
13906   bool result;
13907
13908   arg1 = (Dali::Property::Key *)jarg1;
13909   arg2 = (Dali::Property::Key *)jarg2;
13910   if (!arg2) {
13911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13912     return 0;
13913   }
13914   {
13915     try {
13916       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
13917     } catch (std::out_of_range& e) {
13918       {
13919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13920       };
13921     } catch (std::exception& e) {
13922       {
13923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13924       };
13925     } catch (...) {
13926       {
13927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13928       };
13929     }
13930   }
13931   jresult = result;
13932   return jresult;
13933 }
13934
13935
13936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
13937   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13938
13939   arg1 = (Dali::Property::Key *)jarg1;
13940   {
13941     try {
13942       delete arg1;
13943     } catch (std::out_of_range& e) {
13944       {
13945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13946       };
13947     } catch (std::exception& e) {
13948       {
13949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13950       };
13951     } catch (...) {
13952       {
13953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13954       };
13955     }
13956   }
13957 }
13958
13959
13960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
13961   void * jresult ;
13962   Dali::Property::Map *result = 0 ;
13963
13964   {
13965     try {
13966       result = (Dali::Property::Map *)new Dali::Property::Map();
13967     } catch (std::out_of_range& e) {
13968       {
13969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13970       };
13971     } catch (std::exception& e) {
13972       {
13973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13974       };
13975     } catch (...) {
13976       {
13977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13978       };
13979     }
13980   }
13981   jresult = (void *)result;
13982   return jresult;
13983 }
13984
13985
13986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
13987   void * jresult ;
13988   Dali::Property::Map *arg1 = 0 ;
13989   Dali::Property::Map *result = 0 ;
13990
13991   arg1 = (Dali::Property::Map *)jarg1;
13992   if (!arg1) {
13993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
13994     return 0;
13995   }
13996   {
13997     try {
13998       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
13999     } catch (std::out_of_range& e) {
14000       {
14001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14002       };
14003     } catch (std::exception& e) {
14004       {
14005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14006       };
14007     } catch (...) {
14008       {
14009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14010       };
14011     }
14012   }
14013   jresult = (void *)result;
14014   return jresult;
14015 }
14016
14017
14018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14019   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14020
14021   arg1 = (Dali::Property::Map *)jarg1;
14022   {
14023     try {
14024       delete arg1;
14025     } catch (std::out_of_range& e) {
14026       {
14027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14028       };
14029     } catch (std::exception& e) {
14030       {
14031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14032       };
14033     } catch (...) {
14034       {
14035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14036       };
14037     }
14038   }
14039 }
14040
14041
14042 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14043   unsigned long jresult ;
14044   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14045   Dali::Property::Map::SizeType result;
14046
14047   arg1 = (Dali::Property::Map *)jarg1;
14048   {
14049     try {
14050       result = ((Dali::Property::Map const *)arg1)->Count();
14051     } catch (std::out_of_range& e) {
14052       {
14053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14054       };
14055     } catch (std::exception& e) {
14056       {
14057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14058       };
14059     } catch (...) {
14060       {
14061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14062       };
14063     }
14064   }
14065   jresult = (unsigned long)result;
14066   return jresult;
14067 }
14068
14069
14070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14071   unsigned int jresult ;
14072   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14073   bool result;
14074
14075   arg1 = (Dali::Property::Map *)jarg1;
14076   {
14077     try {
14078       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
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 = result;
14094   return jresult;
14095 }
14096
14097
14098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14099   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14100   char *arg2 = (char *) 0 ;
14101   Dali::Property::Value *arg3 = 0 ;
14102
14103   arg1 = (Dali::Property::Map *)jarg1;
14104   arg2 = (char *)jarg2;
14105   arg3 = (Dali::Property::Value *)jarg3;
14106   if (!arg3) {
14107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14108     return ;
14109   }
14110   {
14111     try {
14112       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14113     } catch (std::out_of_range& e) {
14114       {
14115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14116       };
14117     } catch (std::exception& e) {
14118       {
14119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14120       };
14121     } catch (...) {
14122       {
14123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14124       };
14125     }
14126   }
14127 }
14128
14129
14130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14131   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14132   Dali::Property::Index arg2 ;
14133   Dali::Property::Value *arg3 = 0 ;
14134
14135   arg1 = (Dali::Property::Map *)jarg1;
14136   arg2 = (Dali::Property::Index)jarg2;
14137   arg3 = (Dali::Property::Value *)jarg3;
14138   if (!arg3) {
14139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14140     return ;
14141   }
14142   {
14143     try {
14144       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14145     } catch (std::out_of_range& e) {
14146       {
14147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14148       };
14149     } catch (std::exception& e) {
14150       {
14151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14152       };
14153     } catch (...) {
14154       {
14155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14156       };
14157     }
14158   }
14159 }
14160
14161
14162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14163   void * jresult ;
14164   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14165   char *arg2 = (char *) 0 ;
14166   Dali::Property::Value *arg3 = 0 ;
14167   Dali::Property::Map *result = 0 ;
14168
14169   arg1 = (Dali::Property::Map *)jarg1;
14170   arg2 = (char *)jarg2;
14171   arg3 = (Dali::Property::Value *)jarg3;
14172   if (!arg3) {
14173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14174     return 0;
14175   }
14176   {
14177     try {
14178       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14179     } catch (std::out_of_range& e) {
14180       {
14181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14182       };
14183     } catch (std::exception& e) {
14184       {
14185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14186       };
14187     } catch (...) {
14188       {
14189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14190       };
14191     }
14192   }
14193   jresult = (void *)result;
14194   return jresult;
14195 }
14196
14197
14198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14199   void * jresult ;
14200   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14201   Dali::Property::Index arg2 ;
14202   Dali::Property::Value *arg3 = 0 ;
14203   Dali::Property::Map *result = 0 ;
14204
14205   arg1 = (Dali::Property::Map *)jarg1;
14206   arg2 = (Dali::Property::Index)jarg2;
14207   arg3 = (Dali::Property::Value *)jarg3;
14208   if (!arg3) {
14209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14210     return 0;
14211   }
14212   {
14213     try {
14214       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14215     } catch (std::out_of_range& e) {
14216       {
14217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14218       };
14219     } catch (std::exception& e) {
14220       {
14221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14222       };
14223     } catch (...) {
14224       {
14225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14226       };
14227     }
14228   }
14229   jresult = (void *)result;
14230   return jresult;
14231 }
14232
14233
14234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14235   void * jresult ;
14236   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14237   Dali::Property::Map::SizeType arg2 ;
14238   Dali::Property::Value *result = 0 ;
14239
14240   arg1 = (Dali::Property::Map *)jarg1;
14241   arg2 = (Dali::Property::Map::SizeType)jarg2;
14242   {
14243     try {
14244       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14245     } catch (std::out_of_range& e) {
14246       {
14247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14248       };
14249     } catch (std::exception& e) {
14250       {
14251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14252       };
14253     } catch (...) {
14254       {
14255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14256       };
14257     }
14258   }
14259   jresult = (void *)result;
14260   return jresult;
14261 }
14262
14263
14264 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14265   char * jresult ;
14266   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14267   Dali::Property::Map::SizeType arg2 ;
14268   std::string *result = 0 ;
14269
14270   arg1 = (Dali::Property::Map *)jarg1;
14271   arg2 = (Dali::Property::Map::SizeType)jarg2;
14272   {
14273     try {
14274       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14275     } catch (std::out_of_range& e) {
14276       {
14277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14278       };
14279     } catch (std::exception& e) {
14280       {
14281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14282       };
14283     } catch (...) {
14284       {
14285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14286       };
14287     }
14288   }
14289   jresult = SWIG_csharp_string_callback(result->c_str());
14290   return jresult;
14291 }
14292
14293
14294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14295   void * jresult ;
14296   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14297   Dali::Property::Map::SizeType arg2 ;
14298   SwigValueWrapper< Dali::Property::Key > result;
14299
14300   arg1 = (Dali::Property::Map *)jarg1;
14301   arg2 = (Dali::Property::Map::SizeType)jarg2;
14302   {
14303     try {
14304       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14305     } catch (std::out_of_range& e) {
14306       {
14307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14308       };
14309     } catch (std::exception& e) {
14310       {
14311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14312       };
14313     } catch (...) {
14314       {
14315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14316       };
14317     }
14318   }
14319   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14320   return jresult;
14321 }
14322
14323
14324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14325   void * jresult ;
14326   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14327   Dali::Property::Map::SizeType arg2 ;
14328   StringValuePair *result = 0 ;
14329
14330   arg1 = (Dali::Property::Map *)jarg1;
14331   arg2 = (Dali::Property::Map::SizeType)jarg2;
14332   {
14333     try {
14334       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14335     } catch (std::out_of_range& e) {
14336       {
14337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14338       };
14339     } catch (std::exception& e) {
14340       {
14341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14342       };
14343     } catch (...) {
14344       {
14345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14346       };
14347     }
14348   }
14349   jresult = (void *)result;
14350   return jresult;
14351 }
14352
14353
14354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14355   void * jresult ;
14356   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14357   char *arg2 = (char *) 0 ;
14358   Dali::Property::Value *result = 0 ;
14359
14360   arg1 = (Dali::Property::Map *)jarg1;
14361   arg2 = (char *)jarg2;
14362   {
14363     try {
14364       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14365     } catch (std::out_of_range& e) {
14366       {
14367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14368       };
14369     } catch (std::exception& e) {
14370       {
14371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14372       };
14373     } catch (...) {
14374       {
14375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14376       };
14377     }
14378   }
14379   jresult = (void *)result;
14380   return jresult;
14381 }
14382
14383
14384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14385   void * jresult ;
14386   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14387   Dali::Property::Index arg2 ;
14388   Dali::Property::Value *result = 0 ;
14389
14390   arg1 = (Dali::Property::Map *)jarg1;
14391   arg2 = (Dali::Property::Index)jarg2;
14392   {
14393     try {
14394       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14395     } catch (std::out_of_range& e) {
14396       {
14397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14398       };
14399     } catch (std::exception& e) {
14400       {
14401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14402       };
14403     } catch (...) {
14404       {
14405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14406       };
14407     }
14408   }
14409   jresult = (void *)result;
14410   return jresult;
14411 }
14412
14413
14414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14415   void * jresult ;
14416   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14417   Dali::Property::Index arg2 ;
14418   std::string *arg3 = 0 ;
14419   Dali::Property::Value *result = 0 ;
14420
14421   arg1 = (Dali::Property::Map *)jarg1;
14422   arg2 = (Dali::Property::Index)jarg2;
14423   if (!jarg3) {
14424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14425     return 0;
14426   }
14427   std::string arg3_str(jarg3);
14428   arg3 = &arg3_str;
14429   {
14430     try {
14431       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14432     } catch (std::out_of_range& e) {
14433       {
14434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14435       };
14436     } catch (std::exception& e) {
14437       {
14438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14439       };
14440     } catch (...) {
14441       {
14442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14443       };
14444     }
14445   }
14446   jresult = (void *)result;
14447
14448   //argout typemap for const std::string&
14449
14450   return jresult;
14451 }
14452
14453
14454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14455   void * jresult ;
14456   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14457   std::string *arg2 = 0 ;
14458   Dali::Property::Type arg3 ;
14459   Dali::Property::Value *result = 0 ;
14460
14461   arg1 = (Dali::Property::Map *)jarg1;
14462   if (!jarg2) {
14463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14464     return 0;
14465   }
14466   std::string arg2_str(jarg2);
14467   arg2 = &arg2_str;
14468   arg3 = (Dali::Property::Type)jarg3;
14469   {
14470     try {
14471       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14472     } catch (std::out_of_range& e) {
14473       {
14474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14475       };
14476     } catch (std::exception& e) {
14477       {
14478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14479       };
14480     } catch (...) {
14481       {
14482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14483       };
14484     }
14485   }
14486   jresult = (void *)result;
14487
14488   //argout typemap for const std::string&
14489
14490   return jresult;
14491 }
14492
14493
14494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14495   void * jresult ;
14496   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14497   Dali::Property::Index arg2 ;
14498   Dali::Property::Type arg3 ;
14499   Dali::Property::Value *result = 0 ;
14500
14501   arg1 = (Dali::Property::Map *)jarg1;
14502   arg2 = (Dali::Property::Index)jarg2;
14503   arg3 = (Dali::Property::Type)jarg3;
14504   {
14505     try {
14506       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14507     } catch (std::out_of_range& e) {
14508       {
14509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14510       };
14511     } catch (std::exception& e) {
14512       {
14513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14514       };
14515     } catch (...) {
14516       {
14517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14518       };
14519     }
14520   }
14521   jresult = (void *)result;
14522   return jresult;
14523 }
14524
14525
14526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14527   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14528
14529   arg1 = (Dali::Property::Map *)jarg1;
14530   {
14531     try {
14532       (arg1)->Clear();
14533     } catch (std::out_of_range& e) {
14534       {
14535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14536       };
14537     } catch (std::exception& e) {
14538       {
14539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14540       };
14541     } catch (...) {
14542       {
14543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14544       };
14545     }
14546   }
14547 }
14548
14549
14550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14551   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14552   Dali::Property::Map *arg2 = 0 ;
14553
14554   arg1 = (Dali::Property::Map *)jarg1;
14555   arg2 = (Dali::Property::Map *)jarg2;
14556   if (!arg2) {
14557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14558     return ;
14559   }
14560   {
14561     try {
14562       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14563     } catch (std::out_of_range& e) {
14564       {
14565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14566       };
14567     } catch (std::exception& e) {
14568       {
14569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14570       };
14571     } catch (...) {
14572       {
14573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14574       };
14575     }
14576   }
14577 }
14578
14579
14580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14581   void * jresult ;
14582   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14583   std::string *arg2 = 0 ;
14584   Dali::Property::Value *result = 0 ;
14585
14586   arg1 = (Dali::Property::Map *)jarg1;
14587   if (!jarg2) {
14588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14589     return 0;
14590   }
14591   std::string arg2_str(jarg2);
14592   arg2 = &arg2_str;
14593   {
14594     try {
14595       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14596     } catch (std::out_of_range& e) {
14597       {
14598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14599       };
14600     } catch (std::exception& e) {
14601       {
14602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14603       };
14604     } catch (...) {
14605       {
14606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14607       };
14608     }
14609   }
14610   jresult = (void *)result;
14611
14612   //argout typemap for const std::string&
14613
14614   return jresult;
14615 }
14616
14617
14618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14619   void * jresult ;
14620   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14621   Dali::Property::Index arg2 ;
14622   Dali::Property::Value *result = 0 ;
14623
14624   arg1 = (Dali::Property::Map *)jarg1;
14625   arg2 = (Dali::Property::Index)jarg2;
14626   {
14627     try {
14628       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14629     } catch (std::out_of_range& e) {
14630       {
14631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14632       };
14633     } catch (std::exception& e) {
14634       {
14635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14636       };
14637     } catch (...) {
14638       {
14639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14640       };
14641     }
14642   }
14643   jresult = (void *)result;
14644   return jresult;
14645 }
14646
14647
14648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14649   void * jresult ;
14650   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14651   Dali::Property::Map *arg2 = 0 ;
14652   Dali::Property::Map *result = 0 ;
14653
14654   arg1 = (Dali::Property::Map *)jarg1;
14655   arg2 = (Dali::Property::Map *)jarg2;
14656   if (!arg2) {
14657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14658     return 0;
14659   }
14660   {
14661     try {
14662       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14663     } catch (std::out_of_range& e) {
14664       {
14665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14666       };
14667     } catch (std::exception& e) {
14668       {
14669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14670       };
14671     } catch (...) {
14672       {
14673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14674       };
14675     }
14676   }
14677   jresult = (void *)result;
14678   return jresult;
14679 }
14680
14681
14682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14683   void * jresult ;
14684   Dali::Property::Value *result = 0 ;
14685
14686   {
14687     try {
14688       result = (Dali::Property::Value *)new Dali::Property::Value();
14689     } catch (std::out_of_range& e) {
14690       {
14691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14692       };
14693     } catch (std::exception& e) {
14694       {
14695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14696       };
14697     } catch (...) {
14698       {
14699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14700       };
14701     }
14702   }
14703   jresult = (void *)result;
14704   return jresult;
14705 }
14706
14707
14708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14709   void * jresult ;
14710   bool arg1 ;
14711   Dali::Property::Value *result = 0 ;
14712
14713   arg1 = jarg1 ? true : false;
14714   {
14715     try {
14716       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14717     } catch (std::out_of_range& e) {
14718       {
14719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14720       };
14721     } catch (std::exception& e) {
14722       {
14723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14724       };
14725     } catch (...) {
14726       {
14727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14728       };
14729     }
14730   }
14731   jresult = (void *)result;
14732   return jresult;
14733 }
14734
14735
14736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14737   void * jresult ;
14738   int arg1 ;
14739   Dali::Property::Value *result = 0 ;
14740
14741   arg1 = (int)jarg1;
14742   {
14743     try {
14744       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14745     } catch (std::out_of_range& e) {
14746       {
14747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14748       };
14749     } catch (std::exception& e) {
14750       {
14751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14752       };
14753     } catch (...) {
14754       {
14755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14756       };
14757     }
14758   }
14759   jresult = (void *)result;
14760   return jresult;
14761 }
14762
14763
14764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14765   void * jresult ;
14766   float arg1 ;
14767   Dali::Property::Value *result = 0 ;
14768
14769   arg1 = (float)jarg1;
14770   {
14771     try {
14772       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14773     } catch (std::out_of_range& e) {
14774       {
14775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14776       };
14777     } catch (std::exception& e) {
14778       {
14779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14780       };
14781     } catch (...) {
14782       {
14783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14784       };
14785     }
14786   }
14787   jresult = (void *)result;
14788   return jresult;
14789 }
14790
14791
14792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14793   void * jresult ;
14794   Dali::Vector2 *arg1 = 0 ;
14795   Dali::Property::Value *result = 0 ;
14796
14797   arg1 = (Dali::Vector2 *)jarg1;
14798   if (!arg1) {
14799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14800     return 0;
14801   }
14802   {
14803     try {
14804       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14805     } catch (std::out_of_range& e) {
14806       {
14807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14808       };
14809     } catch (std::exception& e) {
14810       {
14811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14812       };
14813     } catch (...) {
14814       {
14815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14816       };
14817     }
14818   }
14819   jresult = (void *)result;
14820   return jresult;
14821 }
14822
14823
14824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14825   void * jresult ;
14826   Dali::Vector3 *arg1 = 0 ;
14827   Dali::Property::Value *result = 0 ;
14828
14829   arg1 = (Dali::Vector3 *)jarg1;
14830   if (!arg1) {
14831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14832     return 0;
14833   }
14834   {
14835     try {
14836       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14837     } catch (std::out_of_range& e) {
14838       {
14839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14840       };
14841     } catch (std::exception& e) {
14842       {
14843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14844       };
14845     } catch (...) {
14846       {
14847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14848       };
14849     }
14850   }
14851   jresult = (void *)result;
14852   return jresult;
14853 }
14854
14855
14856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14857   void * jresult ;
14858   Dali::Vector4 *arg1 = 0 ;
14859   Dali::Property::Value *result = 0 ;
14860
14861   arg1 = (Dali::Vector4 *)jarg1;
14862   if (!arg1) {
14863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14864     return 0;
14865   }
14866   {
14867     try {
14868       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14869     } catch (std::out_of_range& e) {
14870       {
14871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14872       };
14873     } catch (std::exception& e) {
14874       {
14875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14876       };
14877     } catch (...) {
14878       {
14879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14880       };
14881     }
14882   }
14883   jresult = (void *)result;
14884   return jresult;
14885 }
14886
14887
14888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14889   void * jresult ;
14890   Dali::Matrix3 *arg1 = 0 ;
14891   Dali::Property::Value *result = 0 ;
14892
14893   arg1 = (Dali::Matrix3 *)jarg1;
14894   if (!arg1) {
14895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14896     return 0;
14897   }
14898   {
14899     try {
14900       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
14901     } catch (std::out_of_range& e) {
14902       {
14903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14904       };
14905     } catch (std::exception& e) {
14906       {
14907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14908       };
14909     } catch (...) {
14910       {
14911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14912       };
14913     }
14914   }
14915   jresult = (void *)result;
14916   return jresult;
14917 }
14918
14919
14920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
14921   void * jresult ;
14922   Dali::Matrix *arg1 = 0 ;
14923   Dali::Property::Value *result = 0 ;
14924
14925   arg1 = (Dali::Matrix *)jarg1;
14926   if (!arg1) {
14927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
14928     return 0;
14929   }
14930   {
14931     try {
14932       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
14933     } catch (std::out_of_range& e) {
14934       {
14935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14936       };
14937     } catch (std::exception& e) {
14938       {
14939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14940       };
14941     } catch (...) {
14942       {
14943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14944       };
14945     }
14946   }
14947   jresult = (void *)result;
14948   return jresult;
14949 }
14950
14951
14952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
14953   void * jresult ;
14954   Dali::Rect< int > *arg1 = 0 ;
14955   Dali::Property::Value *result = 0 ;
14956
14957   arg1 = (Dali::Rect< int > *)jarg1;
14958   if (!arg1) {
14959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
14960     return 0;
14961   }
14962   {
14963     try {
14964       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
14965     } catch (std::out_of_range& e) {
14966       {
14967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14968       };
14969     } catch (std::exception& e) {
14970       {
14971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14972       };
14973     } catch (...) {
14974       {
14975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14976       };
14977     }
14978   }
14979   jresult = (void *)result;
14980   return jresult;
14981 }
14982
14983
14984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
14985   void * jresult ;
14986   Dali::AngleAxis *arg1 = 0 ;
14987   Dali::Property::Value *result = 0 ;
14988
14989   arg1 = (Dali::AngleAxis *)jarg1;
14990   if (!arg1) {
14991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14992     return 0;
14993   }
14994   {
14995     try {
14996       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
14997     } catch (std::out_of_range& e) {
14998       {
14999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15000       };
15001     } catch (std::exception& e) {
15002       {
15003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15004       };
15005     } catch (...) {
15006       {
15007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15008       };
15009     }
15010   }
15011   jresult = (void *)result;
15012   return jresult;
15013 }
15014
15015
15016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15017   void * jresult ;
15018   Dali::Quaternion *arg1 = 0 ;
15019   Dali::Property::Value *result = 0 ;
15020
15021   arg1 = (Dali::Quaternion *)jarg1;
15022   if (!arg1) {
15023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15024     return 0;
15025   }
15026   {
15027     try {
15028       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15029     } catch (std::out_of_range& e) {
15030       {
15031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15032       };
15033     } catch (std::exception& e) {
15034       {
15035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15036       };
15037     } catch (...) {
15038       {
15039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15040       };
15041     }
15042   }
15043   jresult = (void *)result;
15044   return jresult;
15045 }
15046
15047
15048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15049   void * jresult ;
15050   std::string *arg1 = 0 ;
15051   Dali::Property::Value *result = 0 ;
15052
15053   if (!jarg1) {
15054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15055     return 0;
15056   }
15057   std::string arg1_str(jarg1);
15058   arg1 = &arg1_str;
15059   {
15060     try {
15061       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15062     } catch (std::out_of_range& e) {
15063       {
15064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15065       };
15066     } catch (std::exception& e) {
15067       {
15068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15069       };
15070     } catch (...) {
15071       {
15072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15073       };
15074     }
15075   }
15076   jresult = (void *)result;
15077
15078   //argout typemap for const std::string&
15079
15080   return jresult;
15081 }
15082
15083
15084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15085   void * jresult ;
15086   Dali::Property::Array *arg1 = 0 ;
15087   Dali::Property::Value *result = 0 ;
15088
15089   arg1 = (Dali::Property::Array *)jarg1;
15090   if (!arg1) {
15091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15092     return 0;
15093   }
15094   {
15095     try {
15096       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15097     } catch (std::out_of_range& e) {
15098       {
15099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15100       };
15101     } catch (std::exception& e) {
15102       {
15103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15104       };
15105     } catch (...) {
15106       {
15107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15108       };
15109     }
15110   }
15111   jresult = (void *)result;
15112   return jresult;
15113 }
15114
15115
15116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15117   void * jresult ;
15118   Dali::Property::Map *arg1 = 0 ;
15119   Dali::Property::Value *result = 0 ;
15120
15121   arg1 = (Dali::Property::Map *)jarg1;
15122   if (!arg1) {
15123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15124     return 0;
15125   }
15126   {
15127     try {
15128       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15129     } catch (std::out_of_range& e) {
15130       {
15131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15132       };
15133     } catch (std::exception& e) {
15134       {
15135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15136       };
15137     } catch (...) {
15138       {
15139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15140       };
15141     }
15142   }
15143   jresult = (void *)result;
15144   return jresult;
15145 }
15146
15147
15148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15149   void * jresult ;
15150   Dali::Property::Type arg1 ;
15151   Dali::Property::Value *result = 0 ;
15152
15153   arg1 = (Dali::Property::Type)jarg1;
15154   {
15155     try {
15156       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15157     } catch (std::out_of_range& e) {
15158       {
15159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15160       };
15161     } catch (std::exception& e) {
15162       {
15163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15164       };
15165     } catch (...) {
15166       {
15167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15168       };
15169     }
15170   }
15171   jresult = (void *)result;
15172   return jresult;
15173 }
15174
15175
15176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15177   void * jresult ;
15178   Dali::Property::Value *arg1 = 0 ;
15179   Dali::Property::Value *result = 0 ;
15180
15181   arg1 = (Dali::Property::Value *)jarg1;
15182   if (!arg1) {
15183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15184     return 0;
15185   }
15186   {
15187     try {
15188       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15189     } catch (std::out_of_range& e) {
15190       {
15191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15192       };
15193     } catch (std::exception& e) {
15194       {
15195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15196       };
15197     } catch (...) {
15198       {
15199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15200       };
15201     }
15202   }
15203   jresult = (void *)result;
15204   return jresult;
15205 }
15206
15207
15208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15209   void * jresult ;
15210   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15211   Dali::Property::Value *arg2 = 0 ;
15212   Dali::Property::Value *result = 0 ;
15213
15214   arg1 = (Dali::Property::Value *)jarg1;
15215   arg2 = (Dali::Property::Value *)jarg2;
15216   if (!arg2) {
15217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15218     return 0;
15219   }
15220   {
15221     try {
15222       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15223     } catch (std::out_of_range& e) {
15224       {
15225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15226       };
15227     } catch (std::exception& e) {
15228       {
15229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15230       };
15231     } catch (...) {
15232       {
15233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15234       };
15235     }
15236   }
15237   jresult = (void *)result;
15238   return jresult;
15239 }
15240
15241
15242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15243   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15244
15245   arg1 = (Dali::Property::Value *)jarg1;
15246   {
15247     try {
15248       delete arg1;
15249     } catch (std::out_of_range& e) {
15250       {
15251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15252       };
15253     } catch (std::exception& e) {
15254       {
15255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15256       };
15257     } catch (...) {
15258       {
15259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15260       };
15261     }
15262   }
15263 }
15264
15265
15266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15267   int jresult ;
15268   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15269   Dali::Property::Type result;
15270
15271   arg1 = (Dali::Property::Value *)jarg1;
15272   {
15273     try {
15274       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15275     } catch (std::out_of_range& e) {
15276       {
15277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15278       };
15279     } catch (std::exception& e) {
15280       {
15281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15282       };
15283     } catch (...) {
15284       {
15285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15286       };
15287     }
15288   }
15289   jresult = (int)result;
15290   return jresult;
15291 }
15292
15293
15294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15295   unsigned int jresult ;
15296   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15297   bool *arg2 = 0 ;
15298   bool result;
15299
15300   arg1 = (Dali::Property::Value *)jarg1;
15301   arg2 = (bool *)jarg2;
15302   {
15303     try {
15304       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15305     } catch (std::out_of_range& e) {
15306       {
15307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15308       };
15309     } catch (std::exception& e) {
15310       {
15311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15312       };
15313     } catch (...) {
15314       {
15315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15316       };
15317     }
15318   }
15319   jresult = result;
15320   return jresult;
15321 }
15322
15323
15324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15325   unsigned int jresult ;
15326   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15327   float *arg2 = 0 ;
15328   bool result;
15329
15330   arg1 = (Dali::Property::Value *)jarg1;
15331   arg2 = (float *)jarg2;
15332   {
15333     try {
15334       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15335     } catch (std::out_of_range& e) {
15336       {
15337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15338       };
15339     } catch (std::exception& e) {
15340       {
15341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15342       };
15343     } catch (...) {
15344       {
15345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15346       };
15347     }
15348   }
15349   jresult = result;
15350   return jresult;
15351 }
15352
15353
15354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15355   unsigned int jresult ;
15356   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15357   int *arg2 = 0 ;
15358   bool result;
15359
15360   arg1 = (Dali::Property::Value *)jarg1;
15361   arg2 = (int *)jarg2;
15362   {
15363     try {
15364       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15365     } catch (std::out_of_range& e) {
15366       {
15367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15368       };
15369     } catch (std::exception& e) {
15370       {
15371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15372       };
15373     } catch (...) {
15374       {
15375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15376       };
15377     }
15378   }
15379   jresult = result;
15380   return jresult;
15381 }
15382
15383
15384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15385   unsigned int jresult ;
15386   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15387   Dali::Rect< int > *arg2 = 0 ;
15388   bool result;
15389
15390   arg1 = (Dali::Property::Value *)jarg1;
15391   arg2 = (Dali::Rect< int > *)jarg2;
15392   if (!arg2) {
15393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15394     return 0;
15395   }
15396   {
15397     try {
15398       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15399     } catch (std::out_of_range& e) {
15400       {
15401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15402       };
15403     } catch (std::exception& e) {
15404       {
15405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15406       };
15407     } catch (...) {
15408       {
15409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15410       };
15411     }
15412   }
15413   jresult = result;
15414   return jresult;
15415 }
15416
15417
15418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15419   unsigned int jresult ;
15420   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15421   Dali::Vector2 *arg2 = 0 ;
15422   bool result;
15423
15424   arg1 = (Dali::Property::Value *)jarg1;
15425   arg2 = (Dali::Vector2 *)jarg2;
15426   if (!arg2) {
15427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15428     return 0;
15429   }
15430   {
15431     try {
15432       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15433     } catch (std::out_of_range& e) {
15434       {
15435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15436       };
15437     } catch (std::exception& e) {
15438       {
15439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15440       };
15441     } catch (...) {
15442       {
15443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15444       };
15445     }
15446   }
15447   jresult = result;
15448   return jresult;
15449 }
15450
15451
15452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15453   unsigned int jresult ;
15454   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15455   Dali::Vector3 *arg2 = 0 ;
15456   bool result;
15457
15458   arg1 = (Dali::Property::Value *)jarg1;
15459   arg2 = (Dali::Vector3 *)jarg2;
15460   if (!arg2) {
15461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15462     return 0;
15463   }
15464   {
15465     try {
15466       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15467     } catch (std::out_of_range& e) {
15468       {
15469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15470       };
15471     } catch (std::exception& e) {
15472       {
15473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15474       };
15475     } catch (...) {
15476       {
15477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15478       };
15479     }
15480   }
15481   jresult = result;
15482   return jresult;
15483 }
15484
15485
15486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15487   unsigned int jresult ;
15488   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15489   Dali::Vector4 *arg2 = 0 ;
15490   bool result;
15491
15492   arg1 = (Dali::Property::Value *)jarg1;
15493   arg2 = (Dali::Vector4 *)jarg2;
15494   if (!arg2) {
15495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15496     return 0;
15497   }
15498   {
15499     try {
15500       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15501     } catch (std::out_of_range& e) {
15502       {
15503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15504       };
15505     } catch (std::exception& e) {
15506       {
15507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15508       };
15509     } catch (...) {
15510       {
15511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15512       };
15513     }
15514   }
15515   jresult = result;
15516   return jresult;
15517 }
15518
15519
15520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15521   unsigned int jresult ;
15522   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15523   Dali::Matrix3 *arg2 = 0 ;
15524   bool result;
15525
15526   arg1 = (Dali::Property::Value *)jarg1;
15527   arg2 = (Dali::Matrix3 *)jarg2;
15528   if (!arg2) {
15529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15530     return 0;
15531   }
15532   {
15533     try {
15534       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15535     } catch (std::out_of_range& e) {
15536       {
15537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15538       };
15539     } catch (std::exception& e) {
15540       {
15541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15542       };
15543     } catch (...) {
15544       {
15545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15546       };
15547     }
15548   }
15549   jresult = result;
15550   return jresult;
15551 }
15552
15553
15554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15555   unsigned int jresult ;
15556   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15557   Dali::Matrix *arg2 = 0 ;
15558   bool result;
15559
15560   arg1 = (Dali::Property::Value *)jarg1;
15561   arg2 = (Dali::Matrix *)jarg2;
15562   if (!arg2) {
15563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15564     return 0;
15565   }
15566   {
15567     try {
15568       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15569     } catch (std::out_of_range& e) {
15570       {
15571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15572       };
15573     } catch (std::exception& e) {
15574       {
15575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15576       };
15577     } catch (...) {
15578       {
15579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15580       };
15581     }
15582   }
15583   jresult = result;
15584   return jresult;
15585 }
15586
15587
15588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15589   unsigned int jresult ;
15590   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15591   Dali::AngleAxis *arg2 = 0 ;
15592   bool result;
15593
15594   arg1 = (Dali::Property::Value *)jarg1;
15595   arg2 = (Dali::AngleAxis *)jarg2;
15596   if (!arg2) {
15597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15598     return 0;
15599   }
15600   {
15601     try {
15602       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15603     } catch (std::out_of_range& e) {
15604       {
15605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15606       };
15607     } catch (std::exception& e) {
15608       {
15609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15610       };
15611     } catch (...) {
15612       {
15613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15614       };
15615     }
15616   }
15617   jresult = result;
15618   return jresult;
15619 }
15620
15621
15622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15623   unsigned int jresult ;
15624   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15625   Dali::Quaternion *arg2 = 0 ;
15626   bool result;
15627
15628   arg1 = (Dali::Property::Value *)jarg1;
15629   arg2 = (Dali::Quaternion *)jarg2;
15630   if (!arg2) {
15631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15632     return 0;
15633   }
15634   {
15635     try {
15636       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15637     } catch (std::out_of_range& e) {
15638       {
15639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15640       };
15641     } catch (std::exception& e) {
15642       {
15643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15644       };
15645     } catch (...) {
15646       {
15647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15648       };
15649     }
15650   }
15651   jresult = result;
15652   return jresult;
15653 }
15654
15655
15656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15657   unsigned int jresult ;
15658   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15659   std::string *arg2 = 0 ;
15660   bool result;
15661
15662   arg1 = (Dali::Property::Value *)jarg1;
15663
15664   //typemap in
15665   std::string temp;
15666   arg2 = &temp;
15667
15668   {
15669     try {
15670       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15671     } catch (std::out_of_range& e) {
15672       {
15673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15674       };
15675     } catch (std::exception& e) {
15676       {
15677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15678       };
15679     } catch (...) {
15680       {
15681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15682       };
15683     }
15684   }
15685   jresult = result;
15686
15687   //Typemap argout in c++ file.
15688   //This will convert c++ string to c# string
15689   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15690
15691   return jresult;
15692 }
15693
15694
15695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15696   unsigned int jresult ;
15697   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15698   Dali::Property::Array *arg2 = 0 ;
15699   bool result;
15700
15701   arg1 = (Dali::Property::Value *)jarg1;
15702   arg2 = (Dali::Property::Array *)jarg2;
15703   if (!arg2) {
15704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15705     return 0;
15706   }
15707   {
15708     try {
15709       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15710     } catch (std::out_of_range& e) {
15711       {
15712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15713       };
15714     } catch (std::exception& e) {
15715       {
15716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15717       };
15718     } catch (...) {
15719       {
15720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15721       };
15722     }
15723   }
15724   jresult = result;
15725   return jresult;
15726 }
15727
15728
15729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15730   unsigned int jresult ;
15731   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15732   Dali::Property::Map *arg2 = 0 ;
15733   bool result;
15734
15735   arg1 = (Dali::Property::Value *)jarg1;
15736   arg2 = (Dali::Property::Map *)jarg2;
15737   if (!arg2) {
15738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15739     return 0;
15740   }
15741   {
15742     try {
15743       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15744     } catch (std::out_of_range& e) {
15745       {
15746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15747       };
15748     } catch (std::exception& e) {
15749       {
15750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15751       };
15752     } catch (...) {
15753       {
15754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15755       };
15756     }
15757   }
15758   jresult = result;
15759   return jresult;
15760 }
15761
15762
15763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15764   void * jresult ;
15765   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15766   Dali::Property::Array *result = 0 ;
15767
15768   arg1 = (Dali::Property::Value *)jarg1;
15769   {
15770     try {
15771       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15772     } catch (std::out_of_range& e) {
15773       {
15774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15775       };
15776     } catch (std::exception& e) {
15777       {
15778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15779       };
15780     } catch (...) {
15781       {
15782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15783       };
15784     }
15785   }
15786   jresult = (void *)result;
15787   return jresult;
15788 }
15789
15790
15791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15792   void * jresult ;
15793   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15794   Dali::Property::Map *result = 0 ;
15795
15796   arg1 = (Dali::Property::Value *)jarg1;
15797   {
15798     try {
15799       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15800     } catch (std::out_of_range& e) {
15801       {
15802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15803       };
15804     } catch (std::exception& e) {
15805       {
15806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15807       };
15808     } catch (...) {
15809       {
15810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15811       };
15812     }
15813   }
15814   jresult = (void *)result;
15815   return jresult;
15816 }
15817
15818
15819 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15820   char * jresult ;
15821   Dali::Property::Type arg1 ;
15822   char *result = 0 ;
15823
15824   arg1 = (Dali::Property::Type)jarg1;
15825   {
15826     try {
15827       result = (char *)Dali::PropertyTypes::GetName(arg1);
15828     } catch (std::out_of_range& e) {
15829       {
15830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15831       };
15832     } catch (std::exception& e) {
15833       {
15834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15835       };
15836     } catch (...) {
15837       {
15838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15839       };
15840     }
15841   }
15842   jresult = SWIG_csharp_string_callback((const char *)result);
15843   return jresult;
15844 }
15845
15846
15847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15848   unsigned int jresult ;
15849   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15850   std::string *arg2 = 0 ;
15851   Dali::Property::Map *arg3 = 0 ;
15852   bool result;
15853
15854   arg1 = (Dali::BaseObject *)jarg1;
15855   if (!jarg2) {
15856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15857     return 0;
15858   }
15859   std::string arg2_str(jarg2);
15860   arg2 = &arg2_str;
15861   arg3 = (Dali::Property::Map *)jarg3;
15862   if (!arg3) {
15863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15864     return 0;
15865   }
15866   {
15867     try {
15868       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15869     } catch (std::out_of_range& e) {
15870       {
15871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15872       };
15873     } catch (std::exception& e) {
15874       {
15875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15876       };
15877     } catch (...) {
15878       {
15879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15880       };
15881     }
15882   }
15883   jresult = result;
15884
15885   //argout typemap for const std::string&
15886
15887   return jresult;
15888 }
15889
15890
15891 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15892   char * jresult ;
15893   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15894   std::string *result = 0 ;
15895
15896   arg1 = (Dali::BaseObject *)jarg1;
15897   {
15898     try {
15899       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
15900     } catch (std::out_of_range& e) {
15901       {
15902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15903       };
15904     } catch (std::exception& e) {
15905       {
15906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15907       };
15908     } catch (...) {
15909       {
15910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15911       };
15912     }
15913   }
15914   jresult = SWIG_csharp_string_callback(result->c_str());
15915   return jresult;
15916 }
15917
15918
15919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
15920   unsigned int jresult ;
15921   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15922   Dali::TypeInfo *arg2 = 0 ;
15923   bool result;
15924
15925   arg1 = (Dali::BaseObject *)jarg1;
15926   arg2 = (Dali::TypeInfo *)jarg2;
15927   if (!arg2) {
15928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
15929     return 0;
15930   }
15931   {
15932     try {
15933       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
15934     } catch (std::out_of_range& e) {
15935       {
15936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15937       };
15938     } catch (std::exception& e) {
15939       {
15940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15941       };
15942     } catch (...) {
15943       {
15944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15945       };
15946     }
15947   }
15948   jresult = result;
15949   return jresult;
15950 }
15951
15952
15953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
15954   unsigned int jresult ;
15955   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15956   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
15957   std::string *arg3 = 0 ;
15958   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
15959   bool result;
15960
15961   arg1 = (Dali::BaseObject *)jarg1;
15962   arg2 = (ConnectionTrackerInterface *)jarg2;
15963   if (!jarg3) {
15964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15965     return 0;
15966   }
15967   std::string arg3_str(jarg3);
15968   arg3 = &arg3_str;
15969   arg4 = (FunctorDelegate *)jarg4;
15970   {
15971     try {
15972       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
15973     } catch (std::out_of_range& e) {
15974       {
15975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15976       };
15977     } catch (std::exception& e) {
15978       {
15979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15980       };
15981     } catch (...) {
15982       {
15983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15984       };
15985     }
15986   }
15987   jresult = result;
15988
15989   //argout typemap for const std::string&
15990
15991   return jresult;
15992 }
15993
15994
15995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
15996   void * jresult ;
15997   Dali::BaseHandle *arg1 = 0 ;
15998   Dali::BaseObject *result = 0 ;
15999
16000   arg1 = (Dali::BaseHandle *)jarg1;
16001   if (!arg1) {
16002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16003     return 0;
16004   }
16005   {
16006     try {
16007       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16008     } catch (std::out_of_range& e) {
16009       {
16010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16011       };
16012     } catch (std::exception& e) {
16013       {
16014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16015       };
16016     } catch (...) {
16017       {
16018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16019       };
16020     }
16021   }
16022   jresult = (void *)result;
16023   return jresult;
16024 }
16025
16026
16027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16028   void * jresult ;
16029   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16030   Dali::BaseHandle *result = 0 ;
16031
16032   arg1 = (Dali::BaseObject *)jarg1;
16033   {
16034     try {
16035       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16036     } catch (std::out_of_range& e) {
16037       {
16038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16039       };
16040     } catch (std::exception& e) {
16041       {
16042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16043       };
16044     } catch (...) {
16045       {
16046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16047       };
16048     }
16049   }
16050   jresult = (void *)result;
16051   return jresult;
16052 }
16053
16054
16055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16056   void * jresult ;
16057   Dali::BaseHandle *result = 0 ;
16058
16059   {
16060     try {
16061       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16062     } catch (std::out_of_range& e) {
16063       {
16064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16065       };
16066     } catch (std::exception& e) {
16067       {
16068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16069       };
16070     } catch (...) {
16071       {
16072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16073       };
16074     }
16075   }
16076   jresult = (void *)result;
16077   return jresult;
16078 }
16079
16080
16081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16082   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16083
16084   arg1 = (Dali::BaseHandle *)jarg1;
16085   {
16086     try {
16087       delete arg1;
16088     } catch (std::out_of_range& e) {
16089       {
16090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16091       };
16092     } catch (std::exception& e) {
16093       {
16094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16095       };
16096     } catch (...) {
16097       {
16098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16099       };
16100     }
16101   }
16102 }
16103
16104
16105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16106   void * jresult ;
16107   Dali::BaseHandle *arg1 = 0 ;
16108   Dali::BaseHandle *result = 0 ;
16109
16110   arg1 = (Dali::BaseHandle *)jarg1;
16111   if (!arg1) {
16112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16113     return 0;
16114   }
16115   {
16116     try {
16117       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16118     } catch (std::out_of_range& e) {
16119       {
16120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16121       };
16122     } catch (std::exception& e) {
16123       {
16124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16125       };
16126     } catch (...) {
16127       {
16128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16129       };
16130     }
16131   }
16132   jresult = (void *)result;
16133   return jresult;
16134 }
16135
16136
16137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16138   void * jresult ;
16139   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16140   Dali::BaseHandle *arg2 = 0 ;
16141   Dali::BaseHandle *result = 0 ;
16142
16143   arg1 = (Dali::BaseHandle *)jarg1;
16144   arg2 = (Dali::BaseHandle *)jarg2;
16145   if (!arg2) {
16146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16147     return 0;
16148   }
16149   {
16150     try {
16151       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16152     } catch (std::out_of_range& e) {
16153       {
16154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16155       };
16156     } catch (std::exception& e) {
16157       {
16158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16159       };
16160     } catch (...) {
16161       {
16162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16163       };
16164     }
16165   }
16166   jresult = (void *)result;
16167   return jresult;
16168 }
16169
16170
16171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16172   unsigned int jresult ;
16173   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16174   std::string *arg2 = 0 ;
16175   Dali::Property::Map *arg3 = 0 ;
16176   bool result;
16177
16178   arg1 = (Dali::BaseHandle *)jarg1;
16179   if (!jarg2) {
16180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16181     return 0;
16182   }
16183   std::string arg2_str(jarg2);
16184   arg2 = &arg2_str;
16185   arg3 = (Dali::Property::Map *)jarg3;
16186   if (!arg3) {
16187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16188     return 0;
16189   }
16190   {
16191     try {
16192       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16193     } catch (std::out_of_range& e) {
16194       {
16195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16196       };
16197     } catch (std::exception& e) {
16198       {
16199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16200       };
16201     } catch (...) {
16202       {
16203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16204       };
16205     }
16206   }
16207   jresult = result;
16208
16209   //argout typemap for const std::string&
16210
16211   return jresult;
16212 }
16213
16214
16215 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16216   char * jresult ;
16217   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16218   std::string *result = 0 ;
16219
16220   arg1 = (Dali::BaseHandle *)jarg1;
16221   {
16222     try {
16223       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16224     } catch (std::out_of_range& e) {
16225       {
16226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16227       };
16228     } catch (std::exception& e) {
16229       {
16230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16231       };
16232     } catch (...) {
16233       {
16234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16235       };
16236     }
16237   }
16238   jresult = SWIG_csharp_string_callback(result->c_str());
16239   return jresult;
16240 }
16241
16242
16243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16244   unsigned int jresult ;
16245   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16246   Dali::TypeInfo *arg2 = 0 ;
16247   bool result;
16248
16249   arg1 = (Dali::BaseHandle *)jarg1;
16250   arg2 = (Dali::TypeInfo *)jarg2;
16251   if (!arg2) {
16252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16253     return 0;
16254   }
16255   {
16256     try {
16257       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16258     } catch (std::out_of_range& e) {
16259       {
16260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16261       };
16262     } catch (std::exception& e) {
16263       {
16264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16265       };
16266     } catch (...) {
16267       {
16268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16269       };
16270     }
16271   }
16272   jresult = result;
16273   return jresult;
16274 }
16275
16276
16277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16278   void * jresult ;
16279   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16280   Dali::BaseObject *result = 0 ;
16281
16282   arg1 = (Dali::BaseHandle *)jarg1;
16283   {
16284     try {
16285       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16286     } catch (std::out_of_range& e) {
16287       {
16288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16289       };
16290     } catch (std::exception& e) {
16291       {
16292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16293       };
16294     } catch (...) {
16295       {
16296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16297       };
16298     }
16299   }
16300   jresult = (void *)result;
16301   return jresult;
16302 }
16303
16304
16305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16306   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16307
16308   arg1 = (Dali::BaseHandle *)jarg1;
16309   {
16310     try {
16311       (arg1)->Reset();
16312     } catch (std::out_of_range& e) {
16313       {
16314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16315       };
16316     } catch (std::exception& e) {
16317       {
16318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16319       };
16320     } catch (...) {
16321       {
16322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16323       };
16324     }
16325   }
16326 }
16327
16328
16329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16330   unsigned int jresult ;
16331   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16332   Dali::BaseHandle *arg2 = 0 ;
16333   bool result;
16334
16335   arg1 = (Dali::BaseHandle *)jarg1;
16336   arg2 = (Dali::BaseHandle *)jarg2;
16337   if (!arg2) {
16338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16339     return 0;
16340   }
16341   {
16342     try {
16343       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16344     } catch (std::out_of_range& e) {
16345       {
16346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16347       };
16348     } catch (std::exception& e) {
16349       {
16350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16351       };
16352     } catch (...) {
16353       {
16354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16355       };
16356     }
16357   }
16358   jresult = result;
16359   return jresult;
16360 }
16361
16362
16363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16364   unsigned int jresult ;
16365   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16366   Dali::BaseHandle *arg2 = 0 ;
16367   bool result;
16368
16369   arg1 = (Dali::BaseHandle *)jarg1;
16370   arg2 = (Dali::BaseHandle *)jarg2;
16371   if (!arg2) {
16372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16373     return 0;
16374   }
16375   {
16376     try {
16377       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16378     } catch (std::out_of_range& e) {
16379       {
16380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16381       };
16382     } catch (std::exception& e) {
16383       {
16384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16385       };
16386     } catch (...) {
16387       {
16388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16389       };
16390     }
16391   }
16392   jresult = result;
16393   return jresult;
16394 }
16395
16396
16397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16398   void * jresult ;
16399   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16400   Dali::RefObject *result = 0 ;
16401
16402   arg1 = (Dali::BaseHandle *)jarg1;
16403   {
16404     try {
16405       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16406     } catch (std::out_of_range& e) {
16407       {
16408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16409       };
16410     } catch (std::exception& e) {
16411       {
16412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16413       };
16414     } catch (...) {
16415       {
16416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16417       };
16418     }
16419   }
16420   jresult = (void *)result;
16421   return jresult;
16422 }
16423
16424
16425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16426   unsigned int jresult ;
16427   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16428   bool result;
16429
16430   arg1 = (Dali::BaseHandle *)jarg1;
16431   {
16432     try {
16433       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16434     } catch (std::out_of_range& e) {
16435       {
16436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16437       };
16438     } catch (std::exception& e) {
16439       {
16440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16441       };
16442     } catch (...) {
16443       {
16444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16445       };
16446     }
16447   }
16448   jresult = result;
16449   return jresult;
16450 }
16451
16452
16453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16454   unsigned int jresult ;
16455   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16456   Dali::BaseHandle *arg2 = 0 ;
16457   bool result;
16458
16459   arg1 = (Dali::BaseHandle *)jarg1;
16460   arg2 = (Dali::BaseHandle *)jarg2;
16461   if (!arg2) {
16462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16463     return 0;
16464   }
16465   {
16466     try {
16467       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16468     } catch (std::out_of_range& e) {
16469       {
16470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16471       };
16472     } catch (std::exception& e) {
16473       {
16474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16475       };
16476     } catch (...) {
16477       {
16478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16479       };
16480     }
16481   }
16482   jresult = result;
16483   return jresult;
16484 }
16485
16486
16487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16488   unsigned int jresult ;
16489   Dali::BaseHandle *arg1 = 0 ;
16490   Dali::BaseHandle *arg2 = 0 ;
16491   bool result;
16492
16493   arg1 = (Dali::BaseHandle *)jarg1;
16494   if (!arg1) {
16495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16496     return 0;
16497   }
16498   arg2 = (Dali::BaseHandle *)jarg2;
16499   if (!arg2) {
16500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16501     return 0;
16502   }
16503   {
16504     try {
16505       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16506     } catch (std::out_of_range& e) {
16507       {
16508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16509       };
16510     } catch (std::exception& e) {
16511       {
16512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16513       };
16514     } catch (...) {
16515       {
16516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16517       };
16518     }
16519   }
16520   jresult = result;
16521   return jresult;
16522 }
16523
16524
16525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16526   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16527
16528   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16529   {
16530     try {
16531       delete arg1;
16532     } catch (std::out_of_range& e) {
16533       {
16534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16535       };
16536     } catch (std::exception& e) {
16537       {
16538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16539       };
16540     } catch (...) {
16541       {
16542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16543       };
16544     }
16545   }
16546 }
16547
16548
16549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16550   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16551   SlotObserver *arg2 = (SlotObserver *) 0 ;
16552   CallbackBase *arg3 = (CallbackBase *) 0 ;
16553
16554   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16555   arg2 = (SlotObserver *)jarg2;
16556   arg3 = (CallbackBase *)jarg3;
16557   {
16558     try {
16559       (arg1)->SignalConnected(arg2,arg3);
16560     } catch (std::out_of_range& e) {
16561       {
16562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16563       };
16564     } catch (std::exception& e) {
16565       {
16566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16567       };
16568     } catch (...) {
16569       {
16570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16571       };
16572     }
16573   }
16574 }
16575
16576
16577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16578   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16579
16580   arg1 = (Dali::SignalObserver *)jarg1;
16581   {
16582     try {
16583       delete arg1;
16584     } catch (std::out_of_range& e) {
16585       {
16586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16587       };
16588     } catch (std::exception& e) {
16589       {
16590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16591       };
16592     } catch (...) {
16593       {
16594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16595       };
16596     }
16597   }
16598 }
16599
16600
16601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16602   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16603   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16604   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16605
16606   arg1 = (Dali::SignalObserver *)jarg1;
16607   arg2 = (Dali::SlotObserver *)jarg2;
16608   arg3 = (Dali::CallbackBase *)jarg3;
16609   {
16610     try {
16611       (arg1)->SignalDisconnected(arg2,arg3);
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_delete_SlotObserver(void * jarg1) {
16630   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16631
16632   arg1 = (Dali::SlotObserver *)jarg1;
16633   {
16634     try {
16635       delete arg1;
16636     } catch (std::out_of_range& e) {
16637       {
16638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16639       };
16640     } catch (std::exception& e) {
16641       {
16642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16643       };
16644     } catch (...) {
16645       {
16646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16647       };
16648     }
16649   }
16650 }
16651
16652
16653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16654   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16655   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16656
16657   arg1 = (Dali::SlotObserver *)jarg1;
16658   arg2 = (Dali::CallbackBase *)jarg2;
16659   {
16660     try {
16661       (arg1)->SlotDisconnected(arg2);
16662     } catch (std::out_of_range& e) {
16663       {
16664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16665       };
16666     } catch (std::exception& e) {
16667       {
16668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16669       };
16670     } catch (...) {
16671       {
16672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16673       };
16674     }
16675   }
16676 }
16677
16678
16679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16680   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16681
16682   arg1 = (Dali::ConnectionTracker *)jarg1;
16683   {
16684     try {
16685       delete arg1;
16686     } catch (std::out_of_range& e) {
16687       {
16688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16689       };
16690     } catch (std::exception& e) {
16691       {
16692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16693       };
16694     } catch (...) {
16695       {
16696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16697       };
16698     }
16699   }
16700 }
16701
16702
16703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16704   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16705
16706   arg1 = (Dali::ConnectionTracker *)jarg1;
16707   {
16708     try {
16709       (arg1)->DisconnectAll();
16710     } catch (std::out_of_range& e) {
16711       {
16712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16713       };
16714     } catch (std::exception& e) {
16715       {
16716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16717       };
16718     } catch (...) {
16719       {
16720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16721       };
16722     }
16723   }
16724 }
16725
16726
16727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16728   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16729   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16730   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16731
16732   arg1 = (Dali::ConnectionTracker *)jarg1;
16733   arg2 = (Dali::SlotObserver *)jarg2;
16734   arg3 = (Dali::CallbackBase *)jarg3;
16735   {
16736     try {
16737       (arg1)->SignalConnected(arg2,arg3);
16738     } catch (std::out_of_range& e) {
16739       {
16740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16741       };
16742     } catch (std::exception& e) {
16743       {
16744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16745       };
16746     } catch (...) {
16747       {
16748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16749       };
16750     }
16751   }
16752 }
16753
16754
16755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16756   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16757   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16758   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16759
16760   arg1 = (Dali::ConnectionTracker *)jarg1;
16761   arg2 = (Dali::SlotObserver *)jarg2;
16762   arg3 = (Dali::CallbackBase *)jarg3;
16763   {
16764     try {
16765       (arg1)->SignalDisconnected(arg2,arg3);
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 unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16784   unsigned long jresult ;
16785   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16786   std::size_t result;
16787
16788   arg1 = (Dali::ConnectionTracker *)jarg1;
16789   {
16790     try {
16791       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16792     } catch (std::out_of_range& e) {
16793       {
16794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16795       };
16796     } catch (std::exception& e) {
16797       {
16798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16799       };
16800     } catch (...) {
16801       {
16802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16803       };
16804     }
16805   }
16806   jresult = (unsigned long)result;
16807   return jresult;
16808 }
16809
16810
16811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16812   void * jresult ;
16813   Dali::ObjectRegistry *result = 0 ;
16814
16815   {
16816     try {
16817       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16818     } catch (std::out_of_range& e) {
16819       {
16820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16821       };
16822     } catch (std::exception& e) {
16823       {
16824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16825       };
16826     } catch (...) {
16827       {
16828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16829       };
16830     }
16831   }
16832   jresult = (void *)result;
16833   return jresult;
16834 }
16835
16836
16837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16838   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16839
16840   arg1 = (Dali::ObjectRegistry *)jarg1;
16841   {
16842     try {
16843       delete arg1;
16844     } catch (std::out_of_range& e) {
16845       {
16846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16847       };
16848     } catch (std::exception& e) {
16849       {
16850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16851       };
16852     } catch (...) {
16853       {
16854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16855       };
16856     }
16857   }
16858 }
16859
16860
16861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16862   void * jresult ;
16863   Dali::ObjectRegistry *arg1 = 0 ;
16864   Dali::ObjectRegistry *result = 0 ;
16865
16866   arg1 = (Dali::ObjectRegistry *)jarg1;
16867   if (!arg1) {
16868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16869     return 0;
16870   }
16871   {
16872     try {
16873       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16874     } catch (std::out_of_range& e) {
16875       {
16876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16877       };
16878     } catch (std::exception& e) {
16879       {
16880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16881       };
16882     } catch (...) {
16883       {
16884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16885       };
16886     }
16887   }
16888   jresult = (void *)result;
16889   return jresult;
16890 }
16891
16892
16893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16894   void * jresult ;
16895   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16896   Dali::ObjectRegistry *arg2 = 0 ;
16897   Dali::ObjectRegistry *result = 0 ;
16898
16899   arg1 = (Dali::ObjectRegistry *)jarg1;
16900   arg2 = (Dali::ObjectRegistry *)jarg2;
16901   if (!arg2) {
16902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16903     return 0;
16904   }
16905   {
16906     try {
16907       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
16908     } catch (std::out_of_range& e) {
16909       {
16910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16911       };
16912     } catch (std::exception& e) {
16913       {
16914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16915       };
16916     } catch (...) {
16917       {
16918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16919       };
16920     }
16921   }
16922   jresult = (void *)result;
16923   return jresult;
16924 }
16925
16926
16927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
16928   void * jresult ;
16929   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16930   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
16931
16932   arg1 = (Dali::ObjectRegistry *)jarg1;
16933   {
16934     try {
16935       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
16936     } catch (std::out_of_range& e) {
16937       {
16938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16939       };
16940     } catch (std::exception& e) {
16941       {
16942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16943       };
16944     } catch (...) {
16945       {
16946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16947       };
16948     }
16949   }
16950   jresult = (void *)result;
16951   return jresult;
16952 }
16953
16954
16955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
16956   void * jresult ;
16957   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16958   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
16959
16960   arg1 = (Dali::ObjectRegistry *)jarg1;
16961   {
16962     try {
16963       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
16964     } catch (std::out_of_range& e) {
16965       {
16966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16967       };
16968     } catch (std::exception& e) {
16969       {
16970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16971       };
16972     } catch (...) {
16973       {
16974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16975       };
16976     }
16977   }
16978   jresult = (void *)result;
16979   return jresult;
16980 }
16981
16982
16983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
16984   void * jresult ;
16985   Dali::PropertyCondition *result = 0 ;
16986
16987   {
16988     try {
16989       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
16990     } catch (std::out_of_range& e) {
16991       {
16992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16993       };
16994     } catch (std::exception& e) {
16995       {
16996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16997       };
16998     } catch (...) {
16999       {
17000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17001       };
17002     }
17003   }
17004   jresult = (void *)result;
17005   return jresult;
17006 }
17007
17008
17009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17010   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17011
17012   arg1 = (Dali::PropertyCondition *)jarg1;
17013   {
17014     try {
17015       delete arg1;
17016     } catch (std::out_of_range& e) {
17017       {
17018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17019       };
17020     } catch (std::exception& e) {
17021       {
17022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17023       };
17024     } catch (...) {
17025       {
17026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17027       };
17028     }
17029   }
17030 }
17031
17032
17033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17034   void * jresult ;
17035   Dali::PropertyCondition *arg1 = 0 ;
17036   Dali::PropertyCondition *result = 0 ;
17037
17038   arg1 = (Dali::PropertyCondition *)jarg1;
17039   if (!arg1) {
17040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17041     return 0;
17042   }
17043   {
17044     try {
17045       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17046     } catch (std::out_of_range& e) {
17047       {
17048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17049       };
17050     } catch (std::exception& e) {
17051       {
17052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17053       };
17054     } catch (...) {
17055       {
17056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17057       };
17058     }
17059   }
17060   jresult = (void *)result;
17061   return jresult;
17062 }
17063
17064
17065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17066   void * jresult ;
17067   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17068   Dali::PropertyCondition *arg2 = 0 ;
17069   Dali::PropertyCondition *result = 0 ;
17070
17071   arg1 = (Dali::PropertyCondition *)jarg1;
17072   arg2 = (Dali::PropertyCondition *)jarg2;
17073   if (!arg2) {
17074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17075     return 0;
17076   }
17077   {
17078     try {
17079       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17080     } catch (std::out_of_range& e) {
17081       {
17082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17083       };
17084     } catch (std::exception& e) {
17085       {
17086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17087       };
17088     } catch (...) {
17089       {
17090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17091       };
17092     }
17093   }
17094   jresult = (void *)result;
17095   return jresult;
17096 }
17097
17098
17099 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17100   unsigned long jresult ;
17101   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17102   std::size_t result;
17103
17104   arg1 = (Dali::PropertyCondition *)jarg1;
17105   {
17106     try {
17107       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17108     } catch (std::out_of_range& e) {
17109       {
17110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17111       };
17112     } catch (std::exception& e) {
17113       {
17114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17115       };
17116     } catch (...) {
17117       {
17118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17119       };
17120     }
17121   }
17122   jresult = (unsigned long)result;
17123   return jresult;
17124 }
17125
17126
17127 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17128   float jresult ;
17129   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17130   std::size_t arg2 ;
17131   float result;
17132
17133   arg1 = (Dali::PropertyCondition *)jarg1;
17134   arg2 = (std::size_t)jarg2;
17135   {
17136     try {
17137       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17138     } catch (std::out_of_range& e) {
17139       {
17140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17141       };
17142     } catch (std::exception& e) {
17143       {
17144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17145       };
17146     } catch (...) {
17147       {
17148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17149       };
17150     }
17151   }
17152   jresult = result;
17153   return jresult;
17154 }
17155
17156
17157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17158   void * jresult ;
17159   float arg1 ;
17160   Dali::PropertyCondition result;
17161
17162   arg1 = (float)jarg1;
17163   {
17164     try {
17165       result = Dali::LessThanCondition(arg1);
17166     } catch (std::out_of_range& e) {
17167       {
17168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17169       };
17170     } catch (std::exception& e) {
17171       {
17172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17173       };
17174     } catch (...) {
17175       {
17176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17177       };
17178     }
17179   }
17180   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17181   return jresult;
17182 }
17183
17184
17185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17186   void * jresult ;
17187   float arg1 ;
17188   Dali::PropertyCondition result;
17189
17190   arg1 = (float)jarg1;
17191   {
17192     try {
17193       result = Dali::GreaterThanCondition(arg1);
17194     } catch (std::out_of_range& e) {
17195       {
17196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17197       };
17198     } catch (std::exception& e) {
17199       {
17200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17201       };
17202     } catch (...) {
17203       {
17204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17205       };
17206     }
17207   }
17208   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17209   return jresult;
17210 }
17211
17212
17213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17214   void * jresult ;
17215   float arg1 ;
17216   float arg2 ;
17217   Dali::PropertyCondition result;
17218
17219   arg1 = (float)jarg1;
17220   arg2 = (float)jarg2;
17221   {
17222     try {
17223       result = Dali::InsideCondition(arg1,arg2);
17224     } catch (std::out_of_range& e) {
17225       {
17226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17227       };
17228     } catch (std::exception& e) {
17229       {
17230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17231       };
17232     } catch (...) {
17233       {
17234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17235       };
17236     }
17237   }
17238   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17239   return jresult;
17240 }
17241
17242
17243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17244   void * jresult ;
17245   float arg1 ;
17246   float arg2 ;
17247   Dali::PropertyCondition result;
17248
17249   arg1 = (float)jarg1;
17250   arg2 = (float)jarg2;
17251   {
17252     try {
17253       result = Dali::OutsideCondition(arg1,arg2);
17254     } catch (std::out_of_range& e) {
17255       {
17256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17257       };
17258     } catch (std::exception& e) {
17259       {
17260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17261       };
17262     } catch (...) {
17263       {
17264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17265       };
17266     }
17267   }
17268   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17269   return jresult;
17270 }
17271
17272
17273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17274   void * jresult ;
17275   float arg1 ;
17276   float arg2 ;
17277   Dali::PropertyCondition result;
17278
17279   arg1 = (float)jarg1;
17280   arg2 = (float)jarg2;
17281   {
17282     try {
17283       result = Dali::StepCondition(arg1,arg2);
17284     } catch (std::out_of_range& e) {
17285       {
17286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17287       };
17288     } catch (std::exception& e) {
17289       {
17290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17291       };
17292     } catch (...) {
17293       {
17294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17295       };
17296     }
17297   }
17298   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17299   return jresult;
17300 }
17301
17302
17303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17304   void * jresult ;
17305   float arg1 ;
17306   Dali::PropertyCondition result;
17307
17308   arg1 = (float)jarg1;
17309   {
17310     try {
17311       result = Dali::StepCondition(arg1);
17312     } catch (std::out_of_range& e) {
17313       {
17314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17315       };
17316     } catch (std::exception& e) {
17317       {
17318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17319       };
17320     } catch (...) {
17321       {
17322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17323       };
17324     }
17325   }
17326   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17327   return jresult;
17328 }
17329
17330
17331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17332   void * jresult ;
17333   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17334   Dali::PropertyCondition result;
17335
17336   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17337   if (!arg1) {
17338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17339     return 0;
17340   }
17341   {
17342     try {
17343       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17344     } catch (std::out_of_range& e) {
17345       {
17346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17347       };
17348     } catch (std::exception& e) {
17349       {
17350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17351       };
17352     } catch (...) {
17353       {
17354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17355       };
17356     }
17357   }
17358   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17359   return jresult;
17360 }
17361
17362
17363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17364   void * jresult ;
17365   Dali::PropertyNotification *result = 0 ;
17366
17367   {
17368     try {
17369       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17370     } catch (std::out_of_range& e) {
17371       {
17372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17373       };
17374     } catch (std::exception& e) {
17375       {
17376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17377       };
17378     } catch (...) {
17379       {
17380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17381       };
17382     }
17383   }
17384   jresult = (void *)result;
17385   return jresult;
17386 }
17387
17388
17389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17390   void * jresult ;
17391   Dali::BaseHandle arg1 ;
17392   Dali::BaseHandle *argp1 ;
17393   Dali::PropertyNotification result;
17394
17395   argp1 = (Dali::BaseHandle *)jarg1;
17396   if (!argp1) {
17397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17398     return 0;
17399   }
17400   arg1 = *argp1;
17401   {
17402     try {
17403       result = Dali::PropertyNotification::DownCast(arg1);
17404     } catch (std::out_of_range& e) {
17405       {
17406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17407       };
17408     } catch (std::exception& e) {
17409       {
17410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17411       };
17412     } catch (...) {
17413       {
17414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17415       };
17416     }
17417   }
17418   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17419   return jresult;
17420 }
17421
17422
17423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17424   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17425
17426   arg1 = (Dali::PropertyNotification *)jarg1;
17427   {
17428     try {
17429       delete arg1;
17430     } catch (std::out_of_range& e) {
17431       {
17432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17433       };
17434     } catch (std::exception& e) {
17435       {
17436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17437       };
17438     } catch (...) {
17439       {
17440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17441       };
17442     }
17443   }
17444 }
17445
17446
17447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17448   void * jresult ;
17449   Dali::PropertyNotification *arg1 = 0 ;
17450   Dali::PropertyNotification *result = 0 ;
17451
17452   arg1 = (Dali::PropertyNotification *)jarg1;
17453   if (!arg1) {
17454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17455     return 0;
17456   }
17457   {
17458     try {
17459       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17460     } catch (std::out_of_range& e) {
17461       {
17462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17463       };
17464     } catch (std::exception& e) {
17465       {
17466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17467       };
17468     } catch (...) {
17469       {
17470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17471       };
17472     }
17473   }
17474   jresult = (void *)result;
17475   return jresult;
17476 }
17477
17478
17479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17480   void * jresult ;
17481   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17482   Dali::PropertyNotification *arg2 = 0 ;
17483   Dali::PropertyNotification *result = 0 ;
17484
17485   arg1 = (Dali::PropertyNotification *)jarg1;
17486   arg2 = (Dali::PropertyNotification *)jarg2;
17487   if (!arg2) {
17488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17489     return 0;
17490   }
17491   {
17492     try {
17493       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17494     } catch (std::out_of_range& e) {
17495       {
17496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17497       };
17498     } catch (std::exception& e) {
17499       {
17500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17501       };
17502     } catch (...) {
17503       {
17504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17505       };
17506     }
17507   }
17508   jresult = (void *)result;
17509   return jresult;
17510 }
17511
17512
17513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17514   void * jresult ;
17515   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17516   Dali::PropertyCondition result;
17517
17518   arg1 = (Dali::PropertyNotification *)jarg1;
17519   {
17520     try {
17521       result = (arg1)->GetCondition();
17522     } catch (std::out_of_range& e) {
17523       {
17524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17525       };
17526     } catch (std::exception& e) {
17527       {
17528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17529       };
17530     } catch (...) {
17531       {
17532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17533       };
17534     }
17535   }
17536   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17537   return jresult;
17538 }
17539
17540
17541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17542   void * jresult ;
17543   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17544   Dali::Handle result;
17545
17546   arg1 = (Dali::PropertyNotification *)jarg1;
17547   {
17548     try {
17549       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17550     } catch (std::out_of_range& e) {
17551       {
17552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17553       };
17554     } catch (std::exception& e) {
17555       {
17556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17557       };
17558     } catch (...) {
17559       {
17560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17561       };
17562     }
17563   }
17564   jresult = new Dali::Handle((const Dali::Handle &)result);
17565   return jresult;
17566 }
17567
17568
17569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17570   int jresult ;
17571   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17572   Dali::Property::Index result;
17573
17574   arg1 = (Dali::PropertyNotification *)jarg1;
17575   {
17576     try {
17577       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17578     } catch (std::out_of_range& e) {
17579       {
17580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17581       };
17582     } catch (std::exception& e) {
17583       {
17584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17585       };
17586     } catch (...) {
17587       {
17588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17589       };
17590     }
17591   }
17592   jresult = result;
17593   return jresult;
17594 }
17595
17596
17597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17598   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17599   Dali::PropertyNotification::NotifyMode arg2 ;
17600
17601   arg1 = (Dali::PropertyNotification *)jarg1;
17602   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17603   {
17604     try {
17605       (arg1)->SetNotifyMode(arg2);
17606     } catch (std::out_of_range& e) {
17607       {
17608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17609       };
17610     } catch (std::exception& e) {
17611       {
17612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17613       };
17614     } catch (...) {
17615       {
17616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17617       };
17618     }
17619   }
17620 }
17621
17622
17623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17624   int jresult ;
17625   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17626   Dali::PropertyNotification::NotifyMode result;
17627
17628   arg1 = (Dali::PropertyNotification *)jarg1;
17629   {
17630     try {
17631       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17632     } catch (std::out_of_range& e) {
17633       {
17634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17635       };
17636     } catch (std::exception& e) {
17637       {
17638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17639       };
17640     } catch (...) {
17641       {
17642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17643       };
17644     }
17645   }
17646   jresult = (int)result;
17647   return jresult;
17648 }
17649
17650
17651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17652   unsigned int jresult ;
17653   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17654   bool result;
17655
17656   arg1 = (Dali::PropertyNotification *)jarg1;
17657   {
17658     try {
17659       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17660     } catch (std::out_of_range& e) {
17661       {
17662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17663       };
17664     } catch (std::exception& e) {
17665       {
17666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17667       };
17668     } catch (...) {
17669       {
17670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17671       };
17672     }
17673   }
17674   jresult = result;
17675   return jresult;
17676 }
17677
17678
17679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17680   void * jresult ;
17681   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17682   Dali::PropertyNotifySignalType *result = 0 ;
17683
17684   arg1 = (Dali::PropertyNotification *)jarg1;
17685   {
17686     try {
17687       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17688     } catch (std::out_of_range& e) {
17689       {
17690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17691       };
17692     } catch (std::exception& e) {
17693       {
17694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17695       };
17696     } catch (...) {
17697       {
17698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17699       };
17700     }
17701   }
17702   jresult = (void *)result;
17703   return jresult;
17704 }
17705
17706
17707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17708   void * jresult ;
17709   Dali::Handle *result = 0 ;
17710
17711   {
17712     try {
17713       result = (Dali::Handle *)new Dali::Handle();
17714     } catch (std::out_of_range& e) {
17715       {
17716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17717       };
17718     } catch (std::exception& e) {
17719       {
17720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17721       };
17722     } catch (...) {
17723       {
17724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17725       };
17726     }
17727   }
17728   jresult = (void *)result;
17729   return jresult;
17730 }
17731
17732
17733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17734   void * jresult ;
17735   Dali::Handle result;
17736
17737   {
17738     try {
17739       result = Dali::Handle::New();
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 = new Dali::Handle((const Dali::Handle &)result);
17755   return jresult;
17756 }
17757
17758
17759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17760   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17761
17762   arg1 = (Dali::Handle *)jarg1;
17763   {
17764     try {
17765       delete arg1;
17766     } catch (std::out_of_range& e) {
17767       {
17768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17769       };
17770     } catch (std::exception& e) {
17771       {
17772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17773       };
17774     } catch (...) {
17775       {
17776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17777       };
17778     }
17779   }
17780 }
17781
17782
17783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17784   void * jresult ;
17785   Dali::Handle *arg1 = 0 ;
17786   Dali::Handle *result = 0 ;
17787
17788   arg1 = (Dali::Handle *)jarg1;
17789   if (!arg1) {
17790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17791     return 0;
17792   }
17793   {
17794     try {
17795       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17796     } catch (std::out_of_range& e) {
17797       {
17798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17799       };
17800     } catch (std::exception& e) {
17801       {
17802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17803       };
17804     } catch (...) {
17805       {
17806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17807       };
17808     }
17809   }
17810   jresult = (void *)result;
17811   return jresult;
17812 }
17813
17814
17815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17816   void * jresult ;
17817   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17818   Dali::Handle *arg2 = 0 ;
17819   Dali::Handle *result = 0 ;
17820
17821   arg1 = (Dali::Handle *)jarg1;
17822   arg2 = (Dali::Handle *)jarg2;
17823   if (!arg2) {
17824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17825     return 0;
17826   }
17827   {
17828     try {
17829       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17830     } catch (std::out_of_range& e) {
17831       {
17832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17833       };
17834     } catch (std::exception& e) {
17835       {
17836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17837       };
17838     } catch (...) {
17839       {
17840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17841       };
17842     }
17843   }
17844   jresult = (void *)result;
17845   return jresult;
17846 }
17847
17848
17849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17850   void * jresult ;
17851   Dali::BaseHandle arg1 ;
17852   Dali::BaseHandle *argp1 ;
17853   Dali::Handle result;
17854
17855   argp1 = (Dali::BaseHandle *)jarg1;
17856   if (!argp1) {
17857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17858     return 0;
17859   }
17860   arg1 = *argp1;
17861   {
17862     try {
17863       result = Dali::Handle::DownCast(arg1);
17864     } catch (std::out_of_range& e) {
17865       {
17866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17867       };
17868     } catch (std::exception& e) {
17869       {
17870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17871       };
17872     } catch (...) {
17873       {
17874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17875       };
17876     }
17877   }
17878   jresult = new Dali::Handle((const Dali::Handle &)result);
17879   return jresult;
17880 }
17881
17882
17883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17884   unsigned int jresult ;
17885   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17886   Dali::Handle::Capability arg2 ;
17887   bool result;
17888
17889   arg1 = (Dali::Handle *)jarg1;
17890   arg2 = (Dali::Handle::Capability)jarg2;
17891   {
17892     try {
17893       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17894     } catch (std::out_of_range& e) {
17895       {
17896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17897       };
17898     } catch (std::exception& e) {
17899       {
17900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17901       };
17902     } catch (...) {
17903       {
17904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17905       };
17906     }
17907   }
17908   jresult = result;
17909   return jresult;
17910 }
17911
17912
17913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
17914   unsigned int jresult ;
17915   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17916   unsigned int result;
17917
17918   arg1 = (Dali::Handle *)jarg1;
17919   {
17920     try {
17921       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
17922     } catch (std::out_of_range& e) {
17923       {
17924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17925       };
17926     } catch (std::exception& e) {
17927       {
17928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17929       };
17930     } catch (...) {
17931       {
17932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17933       };
17934     }
17935   }
17936   jresult = result;
17937   return jresult;
17938 }
17939
17940
17941 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
17942   char * jresult ;
17943   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17944   Dali::Property::Index arg2 ;
17945   std::string result;
17946
17947   arg1 = (Dali::Handle *)jarg1;
17948   arg2 = (Dali::Property::Index)jarg2;
17949   {
17950     try {
17951       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
17952     } catch (std::out_of_range& e) {
17953       {
17954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17955       };
17956     } catch (std::exception& e) {
17957       {
17958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17959       };
17960     } catch (...) {
17961       {
17962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17963       };
17964     }
17965   }
17966   jresult = SWIG_csharp_string_callback((&result)->c_str());
17967   return jresult;
17968 }
17969
17970
17971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
17972   int jresult ;
17973   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17974   std::string *arg2 = 0 ;
17975   Dali::Property::Index result;
17976
17977   arg1 = (Dali::Handle *)jarg1;
17978   if (!jarg2) {
17979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17980     return 0;
17981   }
17982   std::string arg2_str(jarg2);
17983   arg2 = &arg2_str;
17984   {
17985     try {
17986       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
17987     } catch (std::out_of_range& e) {
17988       {
17989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17990       };
17991     } catch (std::exception& e) {
17992       {
17993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17994       };
17995     } catch (...) {
17996       {
17997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17998       };
17999     }
18000   }
18001   jresult = result;
18002
18003   //argout typemap for const std::string&
18004
18005   return jresult;
18006 }
18007
18008
18009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18010   unsigned int jresult ;
18011   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18012   Dali::Property::Index arg2 ;
18013   bool result;
18014
18015   arg1 = (Dali::Handle *)jarg1;
18016   arg2 = (Dali::Property::Index)jarg2;
18017   {
18018     try {
18019       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18020     } catch (std::out_of_range& e) {
18021       {
18022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18023       };
18024     } catch (std::exception& e) {
18025       {
18026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18027       };
18028     } catch (...) {
18029       {
18030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18031       };
18032     }
18033   }
18034   jresult = result;
18035   return jresult;
18036 }
18037
18038
18039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18040   unsigned int jresult ;
18041   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18042   Dali::Property::Index arg2 ;
18043   bool result;
18044
18045   arg1 = (Dali::Handle *)jarg1;
18046   arg2 = (Dali::Property::Index)jarg2;
18047   {
18048     try {
18049       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18050     } catch (std::out_of_range& e) {
18051       {
18052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18053       };
18054     } catch (std::exception& e) {
18055       {
18056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18057       };
18058     } catch (...) {
18059       {
18060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18061       };
18062     }
18063   }
18064   jresult = result;
18065   return jresult;
18066 }
18067
18068
18069 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18070   unsigned int jresult ;
18071   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18072   Dali::Property::Index arg2 ;
18073   bool result;
18074
18075   arg1 = (Dali::Handle *)jarg1;
18076   arg2 = (Dali::Property::Index)jarg2;
18077   {
18078     try {
18079       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18080     } catch (std::out_of_range& e) {
18081       {
18082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18083       };
18084     } catch (std::exception& e) {
18085       {
18086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18087       };
18088     } catch (...) {
18089       {
18090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18091       };
18092     }
18093   }
18094   jresult = result;
18095   return jresult;
18096 }
18097
18098
18099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18100   int jresult ;
18101   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18102   Dali::Property::Index arg2 ;
18103   Dali::Property::Type result;
18104
18105   arg1 = (Dali::Handle *)jarg1;
18106   arg2 = (Dali::Property::Index)jarg2;
18107   {
18108     try {
18109       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18110     } catch (std::out_of_range& e) {
18111       {
18112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18113       };
18114     } catch (std::exception& e) {
18115       {
18116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18117       };
18118     } catch (...) {
18119       {
18120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18121       };
18122     }
18123   }
18124   jresult = (int)result;
18125   return jresult;
18126 }
18127
18128
18129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18130   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18131   Dali::Property::Index arg2 ;
18132   Dali::Property::Value *arg3 = 0 ;
18133
18134   arg1 = (Dali::Handle *)jarg1;
18135   arg2 = (Dali::Property::Index)jarg2;
18136   arg3 = (Dali::Property::Value *)jarg3;
18137   if (!arg3) {
18138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18139     return ;
18140   }
18141   {
18142     try {
18143       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18144     } catch (std::out_of_range& e) {
18145       {
18146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18147       };
18148     } catch (std::exception& e) {
18149       {
18150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18151       };
18152     } catch (...) {
18153       {
18154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18155       };
18156     }
18157   }
18158 }
18159
18160
18161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18162   int jresult ;
18163   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18164   std::string *arg2 = 0 ;
18165   Dali::Property::Value *arg3 = 0 ;
18166   Dali::Property::Index result;
18167
18168   arg1 = (Dali::Handle *)jarg1;
18169   if (!jarg2) {
18170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18171     return 0;
18172   }
18173   std::string arg2_str(jarg2);
18174   arg2 = &arg2_str;
18175   arg3 = (Dali::Property::Value *)jarg3;
18176   if (!arg3) {
18177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18178     return 0;
18179   }
18180   {
18181     try {
18182       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18183     } catch (std::out_of_range& e) {
18184       {
18185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18186       };
18187     } catch (std::exception& e) {
18188       {
18189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18190       };
18191     } catch (...) {
18192       {
18193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18194       };
18195     }
18196   }
18197   jresult = result;
18198
18199   //argout typemap for const std::string&
18200
18201   return jresult;
18202 }
18203
18204
18205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18206   int jresult ;
18207   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18208   std::string *arg2 = 0 ;
18209   Dali::Property::Value *arg3 = 0 ;
18210   Dali::Property::AccessMode arg4 ;
18211   Dali::Property::Index result;
18212
18213   arg1 = (Dali::Handle *)jarg1;
18214   if (!jarg2) {
18215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18216     return 0;
18217   }
18218   std::string arg2_str(jarg2);
18219   arg2 = &arg2_str;
18220   arg3 = (Dali::Property::Value *)jarg3;
18221   if (!arg3) {
18222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18223     return 0;
18224   }
18225   arg4 = (Dali::Property::AccessMode)jarg4;
18226   {
18227     try {
18228       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18229     } catch (std::out_of_range& e) {
18230       {
18231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18232       };
18233     } catch (std::exception& e) {
18234       {
18235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18236       };
18237     } catch (...) {
18238       {
18239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18240       };
18241     }
18242   }
18243   jresult = result;
18244
18245   //argout typemap for const std::string&
18246
18247   return jresult;
18248 }
18249
18250
18251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18252   void * jresult ;
18253   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18254   Dali::Property::Index arg2 ;
18255   Dali::Property::Value result;
18256
18257   arg1 = (Dali::Handle *)jarg1;
18258   arg2 = (Dali::Property::Index)jarg2;
18259   {
18260     try {
18261       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18262     } catch (std::out_of_range& e) {
18263       {
18264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18265       };
18266     } catch (std::exception& e) {
18267       {
18268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18269       };
18270     } catch (...) {
18271       {
18272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18273       };
18274     }
18275   }
18276   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18277   return jresult;
18278 }
18279
18280
18281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18282   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18283   Dali::Property::IndexContainer *arg2 = 0 ;
18284
18285   arg1 = (Dali::Handle *)jarg1;
18286   arg2 = (Dali::Property::IndexContainer *)jarg2;
18287   if (!arg2) {
18288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18289     return ;
18290   }
18291   {
18292     try {
18293       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18294     } catch (std::out_of_range& e) {
18295       {
18296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18297       };
18298     } catch (std::exception& e) {
18299       {
18300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18301       };
18302     } catch (...) {
18303       {
18304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18305       };
18306     }
18307   }
18308 }
18309
18310
18311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18312   void * jresult ;
18313   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18314   Dali::Property::Index arg2 ;
18315   Dali::PropertyCondition *arg3 = 0 ;
18316   Dali::PropertyNotification result;
18317
18318   arg1 = (Dali::Handle *)jarg1;
18319   arg2 = (Dali::Property::Index)jarg2;
18320   arg3 = (Dali::PropertyCondition *)jarg3;
18321   if (!arg3) {
18322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18323     return 0;
18324   }
18325   {
18326     try {
18327       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18328     } catch (std::out_of_range& e) {
18329       {
18330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18331       };
18332     } catch (std::exception& e) {
18333       {
18334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18335       };
18336     } catch (...) {
18337       {
18338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18339       };
18340     }
18341   }
18342   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18343   return jresult;
18344 }
18345
18346
18347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18348   void * jresult ;
18349   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18350   Dali::Property::Index arg2 ;
18351   int arg3 ;
18352   Dali::PropertyCondition *arg4 = 0 ;
18353   Dali::PropertyNotification result;
18354
18355   arg1 = (Dali::Handle *)jarg1;
18356   arg2 = (Dali::Property::Index)jarg2;
18357   arg3 = (int)jarg3;
18358   arg4 = (Dali::PropertyCondition *)jarg4;
18359   if (!arg4) {
18360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18361     return 0;
18362   }
18363   {
18364     try {
18365       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18366     } catch (std::out_of_range& e) {
18367       {
18368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18369       };
18370     } catch (std::exception& e) {
18371       {
18372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18373       };
18374     } catch (...) {
18375       {
18376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18377       };
18378     }
18379   }
18380   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18381   return jresult;
18382 }
18383
18384
18385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18386   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18387   Dali::PropertyNotification arg2 ;
18388   Dali::PropertyNotification *argp2 ;
18389
18390   arg1 = (Dali::Handle *)jarg1;
18391   argp2 = (Dali::PropertyNotification *)jarg2;
18392   if (!argp2) {
18393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18394     return ;
18395   }
18396   arg2 = *argp2;
18397   {
18398     try {
18399       (arg1)->RemovePropertyNotification(arg2);
18400     } catch (std::out_of_range& e) {
18401       {
18402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18403       };
18404     } catch (std::exception& e) {
18405       {
18406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18407       };
18408     } catch (...) {
18409       {
18410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18411       };
18412     }
18413   }
18414 }
18415
18416
18417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18418   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18419
18420   arg1 = (Dali::Handle *)jarg1;
18421   {
18422     try {
18423       (arg1)->RemovePropertyNotifications();
18424     } catch (std::out_of_range& e) {
18425       {
18426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18427       };
18428     } catch (std::exception& e) {
18429       {
18430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18431       };
18432     } catch (...) {
18433       {
18434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18435       };
18436     }
18437   }
18438 }
18439
18440
18441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18442   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18443
18444   arg1 = (Dali::Handle *)jarg1;
18445   {
18446     try {
18447       (arg1)->RemoveConstraints();
18448     } catch (std::out_of_range& e) {
18449       {
18450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18451       };
18452     } catch (std::exception& e) {
18453       {
18454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18455       };
18456     } catch (...) {
18457       {
18458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18459       };
18460     }
18461   }
18462 }
18463
18464
18465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18466   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18467   unsigned int arg2 ;
18468
18469   arg1 = (Dali::Handle *)jarg1;
18470   arg2 = (unsigned int)jarg2;
18471   {
18472     try {
18473       (arg1)->RemoveConstraints(arg2);
18474     } catch (std::out_of_range& e) {
18475       {
18476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18477       };
18478     } catch (std::exception& e) {
18479       {
18480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18481       };
18482     } catch (...) {
18483       {
18484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18485       };
18486     }
18487   }
18488 }
18489
18490
18491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18492   int jresult ;
18493   Dali::Property::Index result;
18494
18495   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18496   jresult = result;
18497   return jresult;
18498 }
18499
18500
18501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18502   void * jresult ;
18503   Dali::Handle result;
18504
18505   {
18506     try {
18507       result = Dali::WeightObject::New();
18508     } catch (std::out_of_range& e) {
18509       {
18510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18511       };
18512     } catch (std::exception& e) {
18513       {
18514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18515       };
18516     } catch (...) {
18517       {
18518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18519       };
18520     }
18521   }
18522   jresult = new Dali::Handle((const Dali::Handle &)result);
18523   return jresult;
18524 }
18525
18526
18527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18528   void * jresult ;
18529   Dali::TypeInfo *result = 0 ;
18530
18531   {
18532     try {
18533       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18534     } catch (std::out_of_range& e) {
18535       {
18536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18537       };
18538     } catch (std::exception& e) {
18539       {
18540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18541       };
18542     } catch (...) {
18543       {
18544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18545       };
18546     }
18547   }
18548   jresult = (void *)result;
18549   return jresult;
18550 }
18551
18552
18553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18554   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18555
18556   arg1 = (Dali::TypeInfo *)jarg1;
18557   {
18558     try {
18559       delete arg1;
18560     } catch (std::out_of_range& e) {
18561       {
18562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18563       };
18564     } catch (std::exception& e) {
18565       {
18566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18567       };
18568     } catch (...) {
18569       {
18570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18571       };
18572     }
18573   }
18574 }
18575
18576
18577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18578   void * jresult ;
18579   Dali::TypeInfo *arg1 = 0 ;
18580   Dali::TypeInfo *result = 0 ;
18581
18582   arg1 = (Dali::TypeInfo *)jarg1;
18583   if (!arg1) {
18584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18585     return 0;
18586   }
18587   {
18588     try {
18589       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18590     } catch (std::out_of_range& e) {
18591       {
18592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18593       };
18594     } catch (std::exception& e) {
18595       {
18596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18597       };
18598     } catch (...) {
18599       {
18600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18601       };
18602     }
18603   }
18604   jresult = (void *)result;
18605   return jresult;
18606 }
18607
18608
18609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18610   void * jresult ;
18611   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18612   Dali::TypeInfo *arg2 = 0 ;
18613   Dali::TypeInfo *result = 0 ;
18614
18615   arg1 = (Dali::TypeInfo *)jarg1;
18616   arg2 = (Dali::TypeInfo *)jarg2;
18617   if (!arg2) {
18618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18619     return 0;
18620   }
18621   {
18622     try {
18623       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18624     } catch (std::out_of_range& e) {
18625       {
18626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18627       };
18628     } catch (std::exception& e) {
18629       {
18630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18631       };
18632     } catch (...) {
18633       {
18634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18635       };
18636     }
18637   }
18638   jresult = (void *)result;
18639   return jresult;
18640 }
18641
18642
18643 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18644   char * jresult ;
18645   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18646   std::string *result = 0 ;
18647
18648   arg1 = (Dali::TypeInfo *)jarg1;
18649   {
18650     try {
18651       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18652     } catch (std::out_of_range& e) {
18653       {
18654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18655       };
18656     } catch (std::exception& e) {
18657       {
18658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18659       };
18660     } catch (...) {
18661       {
18662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18663       };
18664     }
18665   }
18666   jresult = SWIG_csharp_string_callback(result->c_str());
18667   return jresult;
18668 }
18669
18670
18671 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18672   char * jresult ;
18673   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18674   std::string *result = 0 ;
18675
18676   arg1 = (Dali::TypeInfo *)jarg1;
18677   {
18678     try {
18679       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18680     } catch (std::out_of_range& e) {
18681       {
18682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18683       };
18684     } catch (std::exception& e) {
18685       {
18686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18687       };
18688     } catch (...) {
18689       {
18690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18691       };
18692     }
18693   }
18694   jresult = SWIG_csharp_string_callback(result->c_str());
18695   return jresult;
18696 }
18697
18698
18699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18700   void * jresult ;
18701   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18702   Dali::BaseHandle result;
18703
18704   arg1 = (Dali::TypeInfo *)jarg1;
18705   {
18706     try {
18707       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18708     } catch (std::out_of_range& e) {
18709       {
18710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18711       };
18712     } catch (std::exception& e) {
18713       {
18714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18715       };
18716     } catch (...) {
18717       {
18718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18719       };
18720     }
18721   }
18722   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18723   return jresult;
18724 }
18725
18726
18727 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18728   unsigned long jresult ;
18729   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18730   size_t result;
18731
18732   arg1 = (Dali::TypeInfo *)jarg1;
18733   {
18734     try {
18735       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18736     } catch (std::out_of_range& e) {
18737       {
18738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18739       };
18740     } catch (std::exception& e) {
18741       {
18742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18743       };
18744     } catch (...) {
18745       {
18746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18747       };
18748     }
18749   }
18750   jresult = (unsigned long)result;
18751   return jresult;
18752 }
18753
18754
18755 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18756   char * jresult ;
18757   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18758   size_t arg2 ;
18759   std::string result;
18760
18761   arg1 = (Dali::TypeInfo *)jarg1;
18762   arg2 = (size_t)jarg2;
18763   {
18764     try {
18765       result = (arg1)->GetActionName(arg2);
18766     } catch (std::out_of_range& e) {
18767       {
18768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18769       };
18770     } catch (std::exception& e) {
18771       {
18772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18773       };
18774     } catch (...) {
18775       {
18776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18777       };
18778     }
18779   }
18780   jresult = SWIG_csharp_string_callback((&result)->c_str());
18781   return jresult;
18782 }
18783
18784
18785 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18786   unsigned long jresult ;
18787   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18788   size_t result;
18789
18790   arg1 = (Dali::TypeInfo *)jarg1;
18791   {
18792     try {
18793       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18794     } catch (std::out_of_range& e) {
18795       {
18796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18797       };
18798     } catch (std::exception& e) {
18799       {
18800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18801       };
18802     } catch (...) {
18803       {
18804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18805       };
18806     }
18807   }
18808   jresult = (unsigned long)result;
18809   return jresult;
18810 }
18811
18812
18813 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18814   char * jresult ;
18815   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18816   size_t arg2 ;
18817   std::string result;
18818
18819   arg1 = (Dali::TypeInfo *)jarg1;
18820   arg2 = (size_t)jarg2;
18821   {
18822     try {
18823       result = (arg1)->GetSignalName(arg2);
18824     } catch (std::out_of_range& e) {
18825       {
18826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18827       };
18828     } catch (std::exception& e) {
18829       {
18830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18831       };
18832     } catch (...) {
18833       {
18834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18835       };
18836     }
18837   }
18838   jresult = SWIG_csharp_string_callback((&result)->c_str());
18839   return jresult;
18840 }
18841
18842
18843 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18844   unsigned long jresult ;
18845   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18846   size_t result;
18847
18848   arg1 = (Dali::TypeInfo *)jarg1;
18849   {
18850     try {
18851       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18852     } catch (std::out_of_range& e) {
18853       {
18854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18855       };
18856     } catch (std::exception& e) {
18857       {
18858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18859       };
18860     } catch (...) {
18861       {
18862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18863       };
18864     }
18865   }
18866   jresult = (unsigned long)result;
18867   return jresult;
18868 }
18869
18870
18871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18872   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18873   Dali::Property::IndexContainer *arg2 = 0 ;
18874
18875   arg1 = (Dali::TypeInfo *)jarg1;
18876   arg2 = (Dali::Property::IndexContainer *)jarg2;
18877   if (!arg2) {
18878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18879     return ;
18880   }
18881   {
18882     try {
18883       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18884     } catch (std::out_of_range& e) {
18885       {
18886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18887       };
18888     } catch (std::exception& e) {
18889       {
18890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18891       };
18892     } catch (...) {
18893       {
18894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18895       };
18896     }
18897   }
18898 }
18899
18900
18901 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
18902   char * jresult ;
18903   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18904   Dali::Property::Index arg2 ;
18905   std::string *result = 0 ;
18906
18907   arg1 = (Dali::TypeInfo *)jarg1;
18908   arg2 = (Dali::Property::Index)jarg2;
18909   {
18910     try {
18911       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
18912     } catch (std::out_of_range& e) {
18913       {
18914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18915       };
18916     } catch (std::exception& e) {
18917       {
18918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18919       };
18920     } catch (...) {
18921       {
18922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18923       };
18924     }
18925   }
18926   jresult = SWIG_csharp_string_callback(result->c_str());
18927   return jresult;
18928 }
18929
18930
18931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
18932   void * jresult ;
18933   Dali::TypeRegistry result;
18934
18935   {
18936     try {
18937       result = Dali::TypeRegistry::Get();
18938     } catch (std::out_of_range& e) {
18939       {
18940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18941       };
18942     } catch (std::exception& e) {
18943       {
18944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18945       };
18946     } catch (...) {
18947       {
18948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18949       };
18950     }
18951   }
18952   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
18953   return jresult;
18954 }
18955
18956
18957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
18958   void * jresult ;
18959   Dali::TypeRegistry *result = 0 ;
18960
18961   {
18962     try {
18963       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
18964     } catch (std::out_of_range& e) {
18965       {
18966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18967       };
18968     } catch (std::exception& e) {
18969       {
18970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18971       };
18972     } catch (...) {
18973       {
18974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18975       };
18976     }
18977   }
18978   jresult = (void *)result;
18979   return jresult;
18980 }
18981
18982
18983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
18984   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
18985
18986   arg1 = (Dali::TypeRegistry *)jarg1;
18987   {
18988     try {
18989       delete arg1;
18990     } catch (std::out_of_range& e) {
18991       {
18992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18993       };
18994     } catch (std::exception& e) {
18995       {
18996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18997       };
18998     } catch (...) {
18999       {
19000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19001       };
19002     }
19003   }
19004 }
19005
19006
19007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19008   void * jresult ;
19009   Dali::TypeRegistry *arg1 = 0 ;
19010   Dali::TypeRegistry *result = 0 ;
19011
19012   arg1 = (Dali::TypeRegistry *)jarg1;
19013   if (!arg1) {
19014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19015     return 0;
19016   }
19017   {
19018     try {
19019       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19020     } catch (std::out_of_range& e) {
19021       {
19022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19023       };
19024     } catch (std::exception& e) {
19025       {
19026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19027       };
19028     } catch (...) {
19029       {
19030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19031       };
19032     }
19033   }
19034   jresult = (void *)result;
19035   return jresult;
19036 }
19037
19038
19039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19040   void * jresult ;
19041   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19042   Dali::TypeRegistry *arg2 = 0 ;
19043   Dali::TypeRegistry *result = 0 ;
19044
19045   arg1 = (Dali::TypeRegistry *)jarg1;
19046   arg2 = (Dali::TypeRegistry *)jarg2;
19047   if (!arg2) {
19048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19049     return 0;
19050   }
19051   {
19052     try {
19053       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19054     } catch (std::out_of_range& e) {
19055       {
19056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19057       };
19058     } catch (std::exception& e) {
19059       {
19060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19061       };
19062     } catch (...) {
19063       {
19064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19065       };
19066     }
19067   }
19068   jresult = (void *)result;
19069   return jresult;
19070 }
19071
19072
19073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19074   void * jresult ;
19075   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19076   std::string *arg2 = 0 ;
19077   Dali::TypeInfo result;
19078
19079   arg1 = (Dali::TypeRegistry *)jarg1;
19080   if (!jarg2) {
19081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19082     return 0;
19083   }
19084   std::string arg2_str(jarg2);
19085   arg2 = &arg2_str;
19086   {
19087     try {
19088       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19089     } catch (std::out_of_range& e) {
19090       {
19091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19092       };
19093     } catch (std::exception& e) {
19094       {
19095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19096       };
19097     } catch (...) {
19098       {
19099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19100       };
19101     }
19102   }
19103   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19104
19105   //argout typemap for const std::string&
19106
19107   return jresult;
19108 }
19109
19110
19111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19112   void * jresult ;
19113   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19114   std::type_info *arg2 = 0 ;
19115   Dali::TypeInfo result;
19116
19117   arg1 = (Dali::TypeRegistry *)jarg1;
19118   arg2 = (std::type_info *)jarg2;
19119   if (!arg2) {
19120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19121     return 0;
19122   }
19123   {
19124     try {
19125       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19126     } catch (std::out_of_range& e) {
19127       {
19128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19129       };
19130     } catch (std::exception& e) {
19131       {
19132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19133       };
19134     } catch (...) {
19135       {
19136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19137       };
19138     }
19139   }
19140   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19141   return jresult;
19142 }
19143
19144
19145 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19146   unsigned long jresult ;
19147   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19148   size_t result;
19149
19150   arg1 = (Dali::TypeRegistry *)jarg1;
19151   {
19152     try {
19153       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19154     } catch (std::out_of_range& e) {
19155       {
19156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19157       };
19158     } catch (std::exception& e) {
19159       {
19160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19161       };
19162     } catch (...) {
19163       {
19164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19165       };
19166     }
19167   }
19168   jresult = (unsigned long)result;
19169   return jresult;
19170 }
19171
19172
19173 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19174   char * jresult ;
19175   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19176   size_t arg2 ;
19177   std::string result;
19178
19179   arg1 = (Dali::TypeRegistry *)jarg1;
19180   arg2 = (size_t)jarg2;
19181   {
19182     try {
19183       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19184     } catch (std::out_of_range& e) {
19185       {
19186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19187       };
19188     } catch (std::exception& e) {
19189       {
19190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19191       };
19192     } catch (...) {
19193       {
19194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19195       };
19196     }
19197   }
19198   jresult = SWIG_csharp_string_callback((&result)->c_str());
19199   return jresult;
19200 }
19201
19202
19203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19204   void * jresult ;
19205   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19206   Dali::TypeRegistry *result = 0 ;
19207
19208   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19209   {
19210     try {
19211       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19212     } catch (std::out_of_range& e) {
19213       {
19214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19215       };
19216     } catch (std::exception& e) {
19217       {
19218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19219       };
19220     } catch (...) {
19221       {
19222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19223       };
19224     }
19225   }
19226   jresult = (void *)result;
19227   return jresult;
19228 }
19229
19230
19231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19232   void * jresult ;
19233   std::type_info *arg1 = 0 ;
19234   std::type_info *arg2 = 0 ;
19235   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19236   Dali::TypeRegistration *result = 0 ;
19237
19238   arg1 = (std::type_info *)jarg1;
19239   if (!arg1) {
19240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19241     return 0;
19242   }
19243   arg2 = (std::type_info *)jarg2;
19244   if (!arg2) {
19245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19246     return 0;
19247   }
19248   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19249   {
19250     try {
19251       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19252     } catch (std::out_of_range& e) {
19253       {
19254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19255       };
19256     } catch (std::exception& e) {
19257       {
19258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19259       };
19260     } catch (...) {
19261       {
19262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19263       };
19264     }
19265   }
19266   jresult = (void *)result;
19267   return jresult;
19268 }
19269
19270
19271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19272   void * jresult ;
19273   std::type_info *arg1 = 0 ;
19274   std::type_info *arg2 = 0 ;
19275   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19276   bool arg4 ;
19277   Dali::TypeRegistration *result = 0 ;
19278
19279   arg1 = (std::type_info *)jarg1;
19280   if (!arg1) {
19281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19282     return 0;
19283   }
19284   arg2 = (std::type_info *)jarg2;
19285   if (!arg2) {
19286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19287     return 0;
19288   }
19289   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19290   arg4 = jarg4 ? true : false;
19291   {
19292     try {
19293       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19294     } catch (std::out_of_range& e) {
19295       {
19296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19297       };
19298     } catch (std::exception& e) {
19299       {
19300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19301       };
19302     } catch (...) {
19303       {
19304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19305       };
19306     }
19307   }
19308   jresult = (void *)result;
19309   return jresult;
19310 }
19311
19312
19313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19314   void * jresult ;
19315   std::string *arg1 = 0 ;
19316   std::type_info *arg2 = 0 ;
19317   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19318   Dali::TypeRegistration *result = 0 ;
19319
19320   if (!jarg1) {
19321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19322     return 0;
19323   }
19324   std::string arg1_str(jarg1);
19325   arg1 = &arg1_str;
19326   arg2 = (std::type_info *)jarg2;
19327   if (!arg2) {
19328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19329     return 0;
19330   }
19331   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19332   {
19333     try {
19334       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19335     } catch (std::out_of_range& e) {
19336       {
19337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19338       };
19339     } catch (std::exception& e) {
19340       {
19341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19342       };
19343     } catch (...) {
19344       {
19345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19346       };
19347     }
19348   }
19349   jresult = (void *)result;
19350
19351   //argout typemap for const std::string&
19352
19353   return jresult;
19354 }
19355
19356
19357 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19358   char * jresult ;
19359   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19360   std::string result;
19361
19362   arg1 = (Dali::TypeRegistration *)jarg1;
19363   {
19364     try {
19365       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19366     } catch (std::out_of_range& e) {
19367       {
19368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19369       };
19370     } catch (std::exception& e) {
19371       {
19372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19373       };
19374     } catch (...) {
19375       {
19376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19377       };
19378     }
19379   }
19380   jresult = SWIG_csharp_string_callback((&result)->c_str());
19381   return jresult;
19382 }
19383
19384
19385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19386   std::string *arg1 = 0 ;
19387   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19388
19389   if (!jarg1) {
19390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19391     return ;
19392   }
19393   std::string arg1_str(jarg1);
19394   arg1 = &arg1_str;
19395   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19396   {
19397     try {
19398       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19399     } catch (std::out_of_range& e) {
19400       {
19401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19402       };
19403     } catch (std::exception& e) {
19404       {
19405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19406       };
19407     } catch (...) {
19408       {
19409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19410       };
19411     }
19412   }
19413
19414   //argout typemap for const std::string&
19415
19416 }
19417
19418
19419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19420   std::string *arg1 = 0 ;
19421   std::string *arg2 = 0 ;
19422   int arg3 ;
19423   Dali::Property::Type arg4 ;
19424   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19425   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19426
19427   if (!jarg1) {
19428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19429     return ;
19430   }
19431   std::string arg1_str(jarg1);
19432   arg1 = &arg1_str;
19433   if (!jarg2) {
19434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19435     return ;
19436   }
19437   std::string arg2_str(jarg2);
19438   arg2 = &arg2_str;
19439   arg3 = (int)jarg3;
19440   arg4 = (Dali::Property::Type)jarg4;
19441   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19442   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19443   {
19444     try {
19445       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19446     } catch (std::out_of_range& e) {
19447       {
19448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19449       };
19450     } catch (std::exception& e) {
19451       {
19452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19453       };
19454     } catch (...) {
19455       {
19456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19457       };
19458     }
19459   }
19460
19461   //argout typemap for const std::string&
19462
19463
19464   //argout typemap for const std::string&
19465
19466 }
19467
19468
19469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19470   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19471
19472   arg1 = (Dali::TypeRegistration *)jarg1;
19473   {
19474     try {
19475       delete arg1;
19476     } catch (std::out_of_range& e) {
19477       {
19478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19479       };
19480     } catch (std::exception& e) {
19481       {
19482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19483       };
19484     } catch (...) {
19485       {
19486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19487       };
19488     }
19489   }
19490 }
19491
19492
19493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19494   void * jresult ;
19495   Dali::TypeRegistration *arg1 = 0 ;
19496   std::string *arg2 = 0 ;
19497   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19498   Dali::SignalConnectorType *result = 0 ;
19499
19500   arg1 = (Dali::TypeRegistration *)jarg1;
19501   if (!arg1) {
19502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19503     return 0;
19504   }
19505   if (!jarg2) {
19506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19507     return 0;
19508   }
19509   std::string arg2_str(jarg2);
19510   arg2 = &arg2_str;
19511   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19512   {
19513     try {
19514       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19515     } catch (std::out_of_range& e) {
19516       {
19517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19518       };
19519     } catch (std::exception& e) {
19520       {
19521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19522       };
19523     } catch (...) {
19524       {
19525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19526       };
19527     }
19528   }
19529   jresult = (void *)result;
19530
19531   //argout typemap for const std::string&
19532
19533   return jresult;
19534 }
19535
19536
19537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19538   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19539
19540   arg1 = (Dali::SignalConnectorType *)jarg1;
19541   {
19542     try {
19543       delete arg1;
19544     } catch (std::out_of_range& e) {
19545       {
19546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19547       };
19548     } catch (std::exception& e) {
19549       {
19550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19551       };
19552     } catch (...) {
19553       {
19554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19555       };
19556     }
19557   }
19558 }
19559
19560
19561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19562   void * jresult ;
19563   Dali::TypeRegistration *arg1 = 0 ;
19564   std::string *arg2 = 0 ;
19565   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19566   Dali::TypeAction *result = 0 ;
19567
19568   arg1 = (Dali::TypeRegistration *)jarg1;
19569   if (!arg1) {
19570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19571     return 0;
19572   }
19573   if (!jarg2) {
19574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19575     return 0;
19576   }
19577   std::string arg2_str(jarg2);
19578   arg2 = &arg2_str;
19579   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19580   {
19581     try {
19582       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19583     } catch (std::out_of_range& e) {
19584       {
19585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19586       };
19587     } catch (std::exception& e) {
19588       {
19589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19590       };
19591     } catch (...) {
19592       {
19593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19594       };
19595     }
19596   }
19597   jresult = (void *)result;
19598
19599   //argout typemap for const std::string&
19600
19601   return jresult;
19602 }
19603
19604
19605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19606   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19607
19608   arg1 = (Dali::TypeAction *)jarg1;
19609   {
19610     try {
19611       delete arg1;
19612     } catch (std::out_of_range& e) {
19613       {
19614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19615       };
19616     } catch (std::exception& e) {
19617       {
19618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19619       };
19620     } catch (...) {
19621       {
19622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19623       };
19624     }
19625   }
19626 }
19627
19628
19629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19630   void * jresult ;
19631   Dali::TypeRegistration *arg1 = 0 ;
19632   std::string *arg2 = 0 ;
19633   Dali::Property::Index arg3 ;
19634   Dali::Property::Type arg4 ;
19635   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19636   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19637   Dali::PropertyRegistration *result = 0 ;
19638
19639   arg1 = (Dali::TypeRegistration *)jarg1;
19640   if (!arg1) {
19641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19642     return 0;
19643   }
19644   if (!jarg2) {
19645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19646     return 0;
19647   }
19648   std::string arg2_str(jarg2);
19649   arg2 = &arg2_str;
19650   arg3 = (Dali::Property::Index)jarg3;
19651   arg4 = (Dali::Property::Type)jarg4;
19652   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19653   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19654   {
19655     try {
19656       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19657     } catch (std::out_of_range& e) {
19658       {
19659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19660       };
19661     } catch (std::exception& e) {
19662       {
19663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19664       };
19665     } catch (...) {
19666       {
19667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19668       };
19669     }
19670   }
19671   jresult = (void *)result;
19672
19673   //argout typemap for const std::string&
19674
19675   return jresult;
19676 }
19677
19678
19679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19680   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19681
19682   arg1 = (Dali::PropertyRegistration *)jarg1;
19683   {
19684     try {
19685       delete arg1;
19686     } catch (std::out_of_range& e) {
19687       {
19688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19689       };
19690     } catch (std::exception& e) {
19691       {
19692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19693       };
19694     } catch (...) {
19695       {
19696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19697       };
19698     }
19699   }
19700 }
19701
19702
19703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19704   void * jresult ;
19705   Dali::TypeRegistration *arg1 = 0 ;
19706   std::string *arg2 = 0 ;
19707   Dali::Property::Index arg3 ;
19708   Dali::Property::Type arg4 ;
19709   Dali::AnimatablePropertyRegistration *result = 0 ;
19710
19711   arg1 = (Dali::TypeRegistration *)jarg1;
19712   if (!arg1) {
19713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19714     return 0;
19715   }
19716   if (!jarg2) {
19717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19718     return 0;
19719   }
19720   std::string arg2_str(jarg2);
19721   arg2 = &arg2_str;
19722   arg3 = (Dali::Property::Index)jarg3;
19723   arg4 = (Dali::Property::Type)jarg4;
19724   {
19725     try {
19726       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19727     } catch (std::out_of_range& e) {
19728       {
19729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19730       };
19731     } catch (std::exception& e) {
19732       {
19733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19734       };
19735     } catch (...) {
19736       {
19737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19738       };
19739     }
19740   }
19741   jresult = (void *)result;
19742
19743   //argout typemap for const std::string&
19744
19745   return jresult;
19746 }
19747
19748
19749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19750   void * jresult ;
19751   Dali::TypeRegistration *arg1 = 0 ;
19752   std::string *arg2 = 0 ;
19753   Dali::Property::Index arg3 ;
19754   Dali::Property::Value *arg4 = 0 ;
19755   Dali::AnimatablePropertyRegistration *result = 0 ;
19756
19757   arg1 = (Dali::TypeRegistration *)jarg1;
19758   if (!arg1) {
19759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19760     return 0;
19761   }
19762   if (!jarg2) {
19763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19764     return 0;
19765   }
19766   std::string arg2_str(jarg2);
19767   arg2 = &arg2_str;
19768   arg3 = (Dali::Property::Index)jarg3;
19769   arg4 = (Dali::Property::Value *)jarg4;
19770   if (!arg4) {
19771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19772     return 0;
19773   }
19774   {
19775     try {
19776       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19777     } catch (std::out_of_range& e) {
19778       {
19779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19780       };
19781     } catch (std::exception& e) {
19782       {
19783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19784       };
19785     } catch (...) {
19786       {
19787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19788       };
19789     }
19790   }
19791   jresult = (void *)result;
19792
19793   //argout typemap for const std::string&
19794
19795   return jresult;
19796 }
19797
19798
19799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19800   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19801
19802   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19803   {
19804     try {
19805       delete arg1;
19806     } catch (std::out_of_range& e) {
19807       {
19808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19809       };
19810     } catch (std::exception& e) {
19811       {
19812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19813       };
19814     } catch (...) {
19815       {
19816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19817       };
19818     }
19819   }
19820 }
19821
19822
19823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19824   void * jresult ;
19825   Dali::TypeRegistration *arg1 = 0 ;
19826   std::string *arg2 = 0 ;
19827   Dali::Property::Index arg3 ;
19828   Dali::Property::Index arg4 ;
19829   unsigned int arg5 ;
19830   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19831
19832   arg1 = (Dali::TypeRegistration *)jarg1;
19833   if (!arg1) {
19834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19835     return 0;
19836   }
19837   if (!jarg2) {
19838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19839     return 0;
19840   }
19841   std::string arg2_str(jarg2);
19842   arg2 = &arg2_str;
19843   arg3 = (Dali::Property::Index)jarg3;
19844   arg4 = (Dali::Property::Index)jarg4;
19845   arg5 = (unsigned int)jarg5;
19846   {
19847     try {
19848       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19849     } catch (std::out_of_range& e) {
19850       {
19851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19852       };
19853     } catch (std::exception& e) {
19854       {
19855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19856       };
19857     } catch (...) {
19858       {
19859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19860       };
19861     }
19862   }
19863   jresult = (void *)result;
19864
19865   //argout typemap for const std::string&
19866
19867   return jresult;
19868 }
19869
19870
19871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19872   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19873
19874   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19875   {
19876     try {
19877       delete arg1;
19878     } catch (std::out_of_range& e) {
19879       {
19880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19881       };
19882     } catch (std::exception& e) {
19883       {
19884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19885       };
19886     } catch (...) {
19887       {
19888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19889       };
19890     }
19891   }
19892 }
19893
19894
19895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19896   void * jresult ;
19897   Dali::TypeRegistration *arg1 = 0 ;
19898   std::string *arg2 = 0 ;
19899   Dali::Property::Index arg3 ;
19900   Dali::Property::Type arg4 ;
19901   Dali::ChildPropertyRegistration *result = 0 ;
19902
19903   arg1 = (Dali::TypeRegistration *)jarg1;
19904   if (!arg1) {
19905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19906     return 0;
19907   }
19908   if (!jarg2) {
19909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19910     return 0;
19911   }
19912   std::string arg2_str(jarg2);
19913   arg2 = &arg2_str;
19914   arg3 = (Dali::Property::Index)jarg3;
19915   arg4 = (Dali::Property::Type)jarg4;
19916   {
19917     try {
19918       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19919     } catch (std::out_of_range& e) {
19920       {
19921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19922       };
19923     } catch (std::exception& e) {
19924       {
19925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19926       };
19927     } catch (...) {
19928       {
19929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19930       };
19931     }
19932   }
19933   jresult = (void *)result;
19934
19935   //argout typemap for const std::string&
19936
19937   return jresult;
19938 }
19939
19940
19941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
19942   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
19943
19944   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
19945   {
19946     try {
19947       delete arg1;
19948     } catch (std::out_of_range& e) {
19949       {
19950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19951       };
19952     } catch (std::exception& e) {
19953       {
19954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19955       };
19956     } catch (...) {
19957       {
19958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19959       };
19960     }
19961   }
19962 }
19963
19964
19965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
19966   unsigned int jresult ;
19967   std::string *arg1 = 0 ;
19968   std::type_info *arg2 = 0 ;
19969   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19970   bool result;
19971
19972   if (!jarg1) {
19973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19974     return 0;
19975   }
19976   std::string arg1_str(jarg1);
19977   arg1 = &arg1_str;
19978   arg2 = (std::type_info *)jarg2;
19979   if (!arg2) {
19980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19981     return 0;
19982   }
19983   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
19984   {
19985     try {
19986       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19987     } catch (std::out_of_range& e) {
19988       {
19989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19990       };
19991     } catch (std::exception& e) {
19992       {
19993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19994       };
19995     } catch (...) {
19996       {
19997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19998       };
19999     }
20000   }
20001   jresult = result;
20002
20003   //argout typemap for const std::string&
20004
20005   return jresult;
20006 }
20007
20008
20009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20010   unsigned int jresult ;
20011   std::string *arg1 = 0 ;
20012   std::string *arg2 = 0 ;
20013   Dali::Property::Index arg3 ;
20014   Dali::Property::Type arg4 ;
20015   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20016   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20017   bool result;
20018
20019   if (!jarg1) {
20020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20021     return 0;
20022   }
20023   std::string arg1_str(jarg1);
20024   arg1 = &arg1_str;
20025   if (!jarg2) {
20026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20027     return 0;
20028   }
20029   std::string arg2_str(jarg2);
20030   arg2 = &arg2_str;
20031   arg3 = (Dali::Property::Index)jarg3;
20032   arg4 = (Dali::Property::Type)jarg4;
20033   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20034   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20035   {
20036     try {
20037       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20038     } catch (std::out_of_range& e) {
20039       {
20040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20041       };
20042     } catch (std::exception& e) {
20043       {
20044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20045       };
20046     } catch (...) {
20047       {
20048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20049       };
20050     }
20051   }
20052   jresult = result;
20053
20054   //argout typemap for const std::string&
20055
20056
20057   //argout typemap for const std::string&
20058
20059   return jresult;
20060 }
20061
20062
20063 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20064   float jresult ;
20065   float result;
20066
20067   result = (float)(float)Dali::ParentOrigin::TOP;
20068   jresult = result;
20069   return jresult;
20070 }
20071
20072
20073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20074   float jresult ;
20075   float result;
20076
20077   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20078   jresult = result;
20079   return jresult;
20080 }
20081
20082
20083 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20084   float jresult ;
20085   float result;
20086
20087   result = (float)(float)Dali::ParentOrigin::LEFT;
20088   jresult = result;
20089   return jresult;
20090 }
20091
20092
20093 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20094   float jresult ;
20095   float result;
20096
20097   result = (float)(float)Dali::ParentOrigin::RIGHT;
20098   jresult = result;
20099   return jresult;
20100 }
20101
20102
20103 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20104   float jresult ;
20105   float result;
20106
20107   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20108   jresult = result;
20109   return jresult;
20110 }
20111
20112
20113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20114   void * jresult ;
20115   Dali::Vector3 *result = 0 ;
20116
20117   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20118   jresult = (void *)result;
20119   return jresult;
20120 }
20121
20122
20123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20124   void * jresult ;
20125   Dali::Vector3 *result = 0 ;
20126
20127   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20128   jresult = (void *)result;
20129   return jresult;
20130 }
20131
20132
20133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20134   void * jresult ;
20135   Dali::Vector3 *result = 0 ;
20136
20137   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20138   jresult = (void *)result;
20139   return jresult;
20140 }
20141
20142
20143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20144   void * jresult ;
20145   Dali::Vector3 *result = 0 ;
20146
20147   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20148   jresult = (void *)result;
20149   return jresult;
20150 }
20151
20152
20153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20154   void * jresult ;
20155   Dali::Vector3 *result = 0 ;
20156
20157   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20158   jresult = (void *)result;
20159   return jresult;
20160 }
20161
20162
20163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20164   void * jresult ;
20165   Dali::Vector3 *result = 0 ;
20166
20167   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20168   jresult = (void *)result;
20169   return jresult;
20170 }
20171
20172
20173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20174   void * jresult ;
20175   Dali::Vector3 *result = 0 ;
20176
20177   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20178   jresult = (void *)result;
20179   return jresult;
20180 }
20181
20182
20183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20184   void * jresult ;
20185   Dali::Vector3 *result = 0 ;
20186
20187   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20188   jresult = (void *)result;
20189   return jresult;
20190 }
20191
20192
20193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20194   void * jresult ;
20195   Dali::Vector3 *result = 0 ;
20196
20197   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20198   jresult = (void *)result;
20199   return jresult;
20200 }
20201
20202
20203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20204   float jresult ;
20205   float result;
20206
20207   result = (float)(float)Dali::AnchorPoint::TOP;
20208   jresult = result;
20209   return jresult;
20210 }
20211
20212
20213 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20214   float jresult ;
20215   float result;
20216
20217   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20218   jresult = result;
20219   return jresult;
20220 }
20221
20222
20223 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20224   float jresult ;
20225   float result;
20226
20227   result = (float)(float)Dali::AnchorPoint::LEFT;
20228   jresult = result;
20229   return jresult;
20230 }
20231
20232
20233 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20234   float jresult ;
20235   float result;
20236
20237   result = (float)(float)Dali::AnchorPoint::RIGHT;
20238   jresult = result;
20239   return jresult;
20240 }
20241
20242
20243 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20244   float jresult ;
20245   float result;
20246
20247   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20248   jresult = result;
20249   return jresult;
20250 }
20251
20252
20253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20254   void * jresult ;
20255   Dali::Vector3 *result = 0 ;
20256
20257   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20258   jresult = (void *)result;
20259   return jresult;
20260 }
20261
20262
20263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20264   void * jresult ;
20265   Dali::Vector3 *result = 0 ;
20266
20267   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20268   jresult = (void *)result;
20269   return jresult;
20270 }
20271
20272
20273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20274   void * jresult ;
20275   Dali::Vector3 *result = 0 ;
20276
20277   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20278   jresult = (void *)result;
20279   return jresult;
20280 }
20281
20282
20283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20284   void * jresult ;
20285   Dali::Vector3 *result = 0 ;
20286
20287   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20288   jresult = (void *)result;
20289   return jresult;
20290 }
20291
20292
20293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20294   void * jresult ;
20295   Dali::Vector3 *result = 0 ;
20296
20297   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20298   jresult = (void *)result;
20299   return jresult;
20300 }
20301
20302
20303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20304   void * jresult ;
20305   Dali::Vector3 *result = 0 ;
20306
20307   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20308   jresult = (void *)result;
20309   return jresult;
20310 }
20311
20312
20313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20314   void * jresult ;
20315   Dali::Vector3 *result = 0 ;
20316
20317   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20318   jresult = (void *)result;
20319   return jresult;
20320 }
20321
20322
20323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20324   void * jresult ;
20325   Dali::Vector3 *result = 0 ;
20326
20327   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20328   jresult = (void *)result;
20329   return jresult;
20330 }
20331
20332
20333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20334   void * jresult ;
20335   Dali::Vector3 *result = 0 ;
20336
20337   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20338   jresult = (void *)result;
20339   return jresult;
20340 }
20341
20342
20343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20344   void * jresult ;
20345   Dali::Vector4 *result = 0 ;
20346
20347   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20348   jresult = (void *)result;
20349   return jresult;
20350 }
20351
20352
20353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20354   void * jresult ;
20355   Dali::Vector4 *result = 0 ;
20356
20357   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20358   jresult = (void *)result;
20359   return jresult;
20360 }
20361
20362
20363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20364   void * jresult ;
20365   Dali::Vector4 *result = 0 ;
20366
20367   result = (Dali::Vector4 *)&Dali::Color::RED;
20368   jresult = (void *)result;
20369   return jresult;
20370 }
20371
20372
20373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20374   void * jresult ;
20375   Dali::Vector4 *result = 0 ;
20376
20377   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20378   jresult = (void *)result;
20379   return jresult;
20380 }
20381
20382
20383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20384   void * jresult ;
20385   Dali::Vector4 *result = 0 ;
20386
20387   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20388   jresult = (void *)result;
20389   return jresult;
20390 }
20391
20392
20393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20394   void * jresult ;
20395   Dali::Vector4 *result = 0 ;
20396
20397   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20398   jresult = (void *)result;
20399   return jresult;
20400 }
20401
20402
20403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20404   void * jresult ;
20405   Dali::Vector4 *result = 0 ;
20406
20407   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20408   jresult = (void *)result;
20409   return jresult;
20410 }
20411
20412
20413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20414   void * jresult ;
20415   Dali::Vector4 *result = 0 ;
20416
20417   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20418   jresult = (void *)result;
20419   return jresult;
20420 }
20421
20422
20423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20424   void * jresult ;
20425   Dali::Vector4 *result = 0 ;
20426
20427   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20428   jresult = (void *)result;
20429   return jresult;
20430 }
20431
20432
20433 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20434   float jresult ;
20435   float result;
20436
20437   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20438   jresult = result;
20439   return jresult;
20440 }
20441
20442
20443 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20444   float jresult ;
20445   float result;
20446
20447   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20448   jresult = result;
20449   return jresult;
20450 }
20451
20452
20453 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20454   float jresult ;
20455   float result;
20456
20457   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20458   jresult = result;
20459   return jresult;
20460 }
20461
20462
20463 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20464   float jresult ;
20465   float result;
20466
20467   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20468   jresult = result;
20469   return jresult;
20470 }
20471
20472
20473 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20474   float jresult ;
20475   float result;
20476
20477   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20478   jresult = result;
20479   return jresult;
20480 }
20481
20482
20483 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20484   float jresult ;
20485   float result;
20486
20487   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20488   jresult = result;
20489   return jresult;
20490 }
20491
20492
20493 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20494   float jresult ;
20495   float result;
20496
20497   result = (float)(float)Dali::Math::PI;
20498   jresult = result;
20499   return jresult;
20500 }
20501
20502
20503 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20504   float jresult ;
20505   float result;
20506
20507   result = (float)(float)Dali::Math::PI_2;
20508   jresult = result;
20509   return jresult;
20510 }
20511
20512
20513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20514   float jresult ;
20515   float result;
20516
20517   result = (float)(float)Dali::Math::PI_4;
20518   jresult = result;
20519   return jresult;
20520 }
20521
20522
20523 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20524   float jresult ;
20525   float result;
20526
20527   result = (float)(float)Dali::Math::PI_OVER_180;
20528   jresult = result;
20529   return jresult;
20530 }
20531
20532
20533 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20534   float jresult ;
20535   float result;
20536
20537   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20538   jresult = result;
20539   return jresult;
20540 }
20541
20542
20543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20544   int jresult ;
20545   Dali::ResizePolicy::Type result;
20546
20547   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20548   jresult = (int)result;
20549   return jresult;
20550 }
20551
20552
20553 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20554   unsigned long jresult ;
20555   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20556   Dali::VectorBase::SizeType result;
20557
20558   arg1 = (Dali::VectorBase *)jarg1;
20559   {
20560     try {
20561       result = ((Dali::VectorBase const *)arg1)->Count();
20562     } catch (std::out_of_range& e) {
20563       {
20564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20565       };
20566     } catch (std::exception& e) {
20567       {
20568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20569       };
20570     } catch (...) {
20571       {
20572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20573       };
20574     }
20575   }
20576   jresult = (unsigned long)result;
20577   return jresult;
20578 }
20579
20580
20581 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20582   unsigned long jresult ;
20583   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20584   Dali::VectorBase::SizeType result;
20585
20586   arg1 = (Dali::VectorBase *)jarg1;
20587   {
20588     try {
20589       result = ((Dali::VectorBase const *)arg1)->Size();
20590     } catch (std::out_of_range& e) {
20591       {
20592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20593       };
20594     } catch (std::exception& e) {
20595       {
20596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20597       };
20598     } catch (...) {
20599       {
20600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20601       };
20602     }
20603   }
20604   jresult = (unsigned long)result;
20605   return jresult;
20606 }
20607
20608
20609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20610   unsigned int jresult ;
20611   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20612   bool result;
20613
20614   arg1 = (Dali::VectorBase *)jarg1;
20615   {
20616     try {
20617       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20618     } catch (std::out_of_range& e) {
20619       {
20620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20621       };
20622     } catch (std::exception& e) {
20623       {
20624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20625       };
20626     } catch (...) {
20627       {
20628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20629       };
20630     }
20631   }
20632   jresult = result;
20633   return jresult;
20634 }
20635
20636
20637 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20638   unsigned long jresult ;
20639   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20640   Dali::VectorBase::SizeType result;
20641
20642   arg1 = (Dali::VectorBase *)jarg1;
20643   {
20644     try {
20645       result = ((Dali::VectorBase const *)arg1)->Capacity();
20646     } catch (std::out_of_range& e) {
20647       {
20648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20649       };
20650     } catch (std::exception& e) {
20651       {
20652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20653       };
20654     } catch (...) {
20655       {
20656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20657       };
20658     }
20659   }
20660   jresult = (unsigned long)result;
20661   return jresult;
20662 }
20663
20664
20665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20666   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20667
20668   arg1 = (Dali::VectorBase *)jarg1;
20669   {
20670     try {
20671       (arg1)->Release();
20672     } catch (std::out_of_range& e) {
20673       {
20674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20675       };
20676     } catch (std::exception& e) {
20677       {
20678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20679       };
20680     } catch (...) {
20681       {
20682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20683       };
20684     }
20685   }
20686 }
20687
20688
20689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20690   void * jresult ;
20691   Dali::Image *result = 0 ;
20692
20693   {
20694     try {
20695       result = (Dali::Image *)new Dali::Image();
20696     } catch (std::out_of_range& e) {
20697       {
20698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20699       };
20700     } catch (std::exception& e) {
20701       {
20702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20703       };
20704     } catch (...) {
20705       {
20706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20707       };
20708     }
20709   }
20710   jresult = (void *)result;
20711   return jresult;
20712 }
20713
20714
20715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20716   Dali::Image *arg1 = (Dali::Image *) 0 ;
20717
20718   arg1 = (Dali::Image *)jarg1;
20719   {
20720     try {
20721       delete arg1;
20722     } catch (std::out_of_range& e) {
20723       {
20724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20725       };
20726     } catch (std::exception& e) {
20727       {
20728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20729       };
20730     } catch (...) {
20731       {
20732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20733       };
20734     }
20735   }
20736 }
20737
20738
20739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20740   void * jresult ;
20741   Dali::Image *arg1 = 0 ;
20742   Dali::Image *result = 0 ;
20743
20744   arg1 = (Dali::Image *)jarg1;
20745   if (!arg1) {
20746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20747     return 0;
20748   }
20749   {
20750     try {
20751       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20752     } catch (std::out_of_range& e) {
20753       {
20754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20755       };
20756     } catch (std::exception& e) {
20757       {
20758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20759       };
20760     } catch (...) {
20761       {
20762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20763       };
20764     }
20765   }
20766   jresult = (void *)result;
20767   return jresult;
20768 }
20769
20770
20771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20772   void * jresult ;
20773   Dali::Image *arg1 = (Dali::Image *) 0 ;
20774   Dali::Image *arg2 = 0 ;
20775   Dali::Image *result = 0 ;
20776
20777   arg1 = (Dali::Image *)jarg1;
20778   arg2 = (Dali::Image *)jarg2;
20779   if (!arg2) {
20780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20781     return 0;
20782   }
20783   {
20784     try {
20785       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20786     } catch (std::out_of_range& e) {
20787       {
20788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20789       };
20790     } catch (std::exception& e) {
20791       {
20792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20793       };
20794     } catch (...) {
20795       {
20796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20797       };
20798     }
20799   }
20800   jresult = (void *)result;
20801   return jresult;
20802 }
20803
20804
20805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20806   void * jresult ;
20807   Dali::BaseHandle arg1 ;
20808   Dali::BaseHandle *argp1 ;
20809   Dali::Image result;
20810
20811   argp1 = (Dali::BaseHandle *)jarg1;
20812   if (!argp1) {
20813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20814     return 0;
20815   }
20816   arg1 = *argp1;
20817   {
20818     try {
20819       result = Dali::Image::DownCast(arg1);
20820     } catch (std::out_of_range& e) {
20821       {
20822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20823       };
20824     } catch (std::exception& e) {
20825       {
20826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20827       };
20828     } catch (...) {
20829       {
20830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20831       };
20832     }
20833   }
20834   jresult = new Dali::Image((const Dali::Image &)result);
20835   return jresult;
20836 }
20837
20838
20839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20840   unsigned int jresult ;
20841   Dali::Image *arg1 = (Dali::Image *) 0 ;
20842   unsigned int result;
20843
20844   arg1 = (Dali::Image *)jarg1;
20845   {
20846     try {
20847       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20848     } catch (std::out_of_range& e) {
20849       {
20850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20851       };
20852     } catch (std::exception& e) {
20853       {
20854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20855       };
20856     } catch (...) {
20857       {
20858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20859       };
20860     }
20861   }
20862   jresult = result;
20863   return jresult;
20864 }
20865
20866
20867 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20868   unsigned int jresult ;
20869   Dali::Image *arg1 = (Dali::Image *) 0 ;
20870   unsigned int result;
20871
20872   arg1 = (Dali::Image *)jarg1;
20873   {
20874     try {
20875       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20876     } catch (std::out_of_range& e) {
20877       {
20878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20879       };
20880     } catch (std::exception& e) {
20881       {
20882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20883       };
20884     } catch (...) {
20885       {
20886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20887       };
20888     }
20889   }
20890   jresult = result;
20891   return jresult;
20892 }
20893
20894
20895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20896   void * jresult ;
20897   Dali::Image *arg1 = (Dali::Image *) 0 ;
20898   Dali::Image::ImageSignalType *result = 0 ;
20899
20900   arg1 = (Dali::Image *)jarg1;
20901   {
20902     try {
20903       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
20904     } catch (std::out_of_range& e) {
20905       {
20906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20907       };
20908     } catch (std::exception& e) {
20909       {
20910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20911       };
20912     } catch (...) {
20913       {
20914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20915       };
20916     }
20917   }
20918   jresult = (void *)result;
20919   return jresult;
20920 }
20921
20922
20923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
20924   int jresult ;
20925   Dali::Pixel::Format result;
20926
20927   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
20928   jresult = (int)result;
20929   return jresult;
20930 }
20931
20932
20933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
20934   int jresult ;
20935   Dali::Pixel::Format result;
20936
20937   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
20938   jresult = (int)result;
20939   return jresult;
20940 }
20941
20942
20943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
20944   unsigned int jresult ;
20945   Dali::Pixel::Format arg1 ;
20946   bool result;
20947
20948   arg1 = (Dali::Pixel::Format)jarg1;
20949   {
20950     try {
20951       result = (bool)Dali::Pixel::HasAlpha(arg1);
20952     } catch (std::out_of_range& e) {
20953       {
20954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20955       };
20956     } catch (std::exception& e) {
20957       {
20958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20959       };
20960     } catch (...) {
20961       {
20962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20963       };
20964     }
20965   }
20966   jresult = result;
20967   return jresult;
20968 }
20969
20970
20971 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
20972   unsigned int jresult ;
20973   Dali::Pixel::Format arg1 ;
20974   unsigned int result;
20975
20976   arg1 = (Dali::Pixel::Format)jarg1;
20977   {
20978     try {
20979       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
20980     } catch (std::out_of_range& e) {
20981       {
20982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20983       };
20984     } catch (std::exception& e) {
20985       {
20986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20987       };
20988     } catch (...) {
20989       {
20990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20991       };
20992     }
20993   }
20994   jresult = result;
20995   return jresult;
20996 }
20997
20998
20999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21000   Dali::Pixel::Format arg1 ;
21001   int *arg2 = 0 ;
21002   int *arg3 = 0 ;
21003
21004   arg1 = (Dali::Pixel::Format)jarg1;
21005   arg2 = (int *)jarg2;
21006   if (!arg2) {
21007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21008     return ;
21009   }
21010   arg3 = (int *)jarg3;
21011   if (!arg3) {
21012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21013     return ;
21014   }
21015   {
21016     try {
21017       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21018     } catch (std::out_of_range& e) {
21019       {
21020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21021       };
21022     } catch (std::exception& e) {
21023       {
21024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21025       };
21026     } catch (...) {
21027       {
21028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21029       };
21030     }
21031   }
21032 }
21033
21034
21035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21036   void * jresult ;
21037   unsigned char *arg1 = (unsigned char *) 0 ;
21038   unsigned int arg2 ;
21039   unsigned int arg3 ;
21040   unsigned int arg4 ;
21041   Dali::Pixel::Format arg5 ;
21042   Dali::PixelData::ReleaseFunction arg6 ;
21043   Dali::PixelData result;
21044
21045   arg1 = jarg1;
21046   arg2 = (unsigned int)jarg2;
21047   arg3 = (unsigned int)jarg3;
21048   arg4 = (unsigned int)jarg4;
21049   arg5 = (Dali::Pixel::Format)jarg5;
21050   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21051   {
21052     try {
21053       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21054     } catch (std::out_of_range& e) {
21055       {
21056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21057       };
21058     } catch (std::exception& e) {
21059       {
21060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21061       };
21062     } catch (...) {
21063       {
21064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21065       };
21066     }
21067   }
21068   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21069
21070
21071   return jresult;
21072 }
21073
21074
21075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21076   void * jresult ;
21077   Dali::PixelData *result = 0 ;
21078
21079   {
21080     try {
21081       result = (Dali::PixelData *)new Dali::PixelData();
21082     } catch (std::out_of_range& e) {
21083       {
21084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21085       };
21086     } catch (std::exception& e) {
21087       {
21088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21089       };
21090     } catch (...) {
21091       {
21092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21093       };
21094     }
21095   }
21096   jresult = (void *)result;
21097   return jresult;
21098 }
21099
21100
21101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21102   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21103
21104   arg1 = (Dali::PixelData *)jarg1;
21105   {
21106     try {
21107       delete arg1;
21108     } catch (std::out_of_range& e) {
21109       {
21110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21111       };
21112     } catch (std::exception& e) {
21113       {
21114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21115       };
21116     } catch (...) {
21117       {
21118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21119       };
21120     }
21121   }
21122 }
21123
21124
21125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21126   void * jresult ;
21127   Dali::PixelData *arg1 = 0 ;
21128   Dali::PixelData *result = 0 ;
21129
21130   arg1 = (Dali::PixelData *)jarg1;
21131   if (!arg1) {
21132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21133     return 0;
21134   }
21135   {
21136     try {
21137       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21138     } catch (std::out_of_range& e) {
21139       {
21140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21141       };
21142     } catch (std::exception& e) {
21143       {
21144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21145       };
21146     } catch (...) {
21147       {
21148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21149       };
21150     }
21151   }
21152   jresult = (void *)result;
21153   return jresult;
21154 }
21155
21156
21157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21158   void * jresult ;
21159   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21160   Dali::PixelData *arg2 = 0 ;
21161   Dali::PixelData *result = 0 ;
21162
21163   arg1 = (Dali::PixelData *)jarg1;
21164   arg2 = (Dali::PixelData *)jarg2;
21165   if (!arg2) {
21166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21167     return 0;
21168   }
21169   {
21170     try {
21171       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21172     } catch (std::out_of_range& e) {
21173       {
21174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21175       };
21176     } catch (std::exception& e) {
21177       {
21178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21179       };
21180     } catch (...) {
21181       {
21182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21183       };
21184     }
21185   }
21186   jresult = (void *)result;
21187   return jresult;
21188 }
21189
21190
21191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21192   unsigned int jresult ;
21193   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21194   unsigned int result;
21195
21196   arg1 = (Dali::PixelData *)jarg1;
21197   {
21198     try {
21199       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21200     } catch (std::out_of_range& e) {
21201       {
21202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21203       };
21204     } catch (std::exception& e) {
21205       {
21206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21207       };
21208     } catch (...) {
21209       {
21210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21211       };
21212     }
21213   }
21214   jresult = result;
21215   return jresult;
21216 }
21217
21218
21219 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21220   unsigned int jresult ;
21221   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21222   unsigned int result;
21223
21224   arg1 = (Dali::PixelData *)jarg1;
21225   {
21226     try {
21227       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21228     } catch (std::out_of_range& e) {
21229       {
21230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21231       };
21232     } catch (std::exception& e) {
21233       {
21234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21235       };
21236     } catch (...) {
21237       {
21238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21239       };
21240     }
21241   }
21242   jresult = result;
21243   return jresult;
21244 }
21245
21246
21247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21248   int jresult ;
21249   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21250   Dali::Pixel::Format result;
21251
21252   arg1 = (Dali::PixelData *)jarg1;
21253   {
21254     try {
21255       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21256     } catch (std::out_of_range& e) {
21257       {
21258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21259       };
21260     } catch (std::exception& e) {
21261       {
21262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21263       };
21264     } catch (...) {
21265       {
21266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21267       };
21268     }
21269   }
21270   jresult = (int)result;
21271   return jresult;
21272 }
21273
21274
21275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21276   unsigned int jresult ;
21277   unsigned int result;
21278
21279   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21280   jresult = result;
21281   return jresult;
21282 }
21283
21284
21285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21286   unsigned int jresult ;
21287   unsigned int result;
21288
21289   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21290   jresult = result;
21291   return jresult;
21292 }
21293
21294
21295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21296   unsigned int jresult ;
21297   unsigned int result;
21298
21299   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21300   jresult = result;
21301   return jresult;
21302 }
21303
21304
21305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21306   unsigned int jresult ;
21307   unsigned int result;
21308
21309   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21310   jresult = result;
21311   return jresult;
21312 }
21313
21314
21315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21316   unsigned int jresult ;
21317   unsigned int result;
21318
21319   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21320   jresult = result;
21321   return jresult;
21322 }
21323
21324
21325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21326   unsigned int jresult ;
21327   unsigned int result;
21328
21329   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21330   jresult = result;
21331   return jresult;
21332 }
21333
21334
21335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21336   void * jresult ;
21337   Dali::TextureType::Type arg1 ;
21338   Dali::Pixel::Format arg2 ;
21339   unsigned int arg3 ;
21340   unsigned int arg4 ;
21341   Dali::Texture result;
21342
21343   arg1 = (Dali::TextureType::Type)jarg1;
21344   arg2 = (Dali::Pixel::Format)jarg2;
21345   arg3 = (unsigned int)jarg3;
21346   arg4 = (unsigned int)jarg4;
21347   {
21348     try {
21349       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21350     } catch (std::out_of_range& e) {
21351       {
21352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21353       };
21354     } catch (std::exception& e) {
21355       {
21356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21357       };
21358     } catch (...) {
21359       {
21360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21361       };
21362     }
21363   }
21364   jresult = new Dali::Texture((const Dali::Texture &)result);
21365   return jresult;
21366 }
21367
21368
21369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21370   void * jresult ;
21371   NativeImageInterface *arg1 = 0 ;
21372   Dali::Texture result;
21373
21374   arg1 = (NativeImageInterface *)jarg1;
21375   if (!arg1) {
21376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21377     return 0;
21378   }
21379   {
21380     try {
21381       result = Dali::Texture::New(*arg1);
21382     } catch (std::out_of_range& e) {
21383       {
21384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21385       };
21386     } catch (std::exception& e) {
21387       {
21388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21389       };
21390     } catch (...) {
21391       {
21392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21393       };
21394     }
21395   }
21396   jresult = new Dali::Texture((const Dali::Texture &)result);
21397   return jresult;
21398 }
21399
21400
21401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21402   void * jresult ;
21403   Dali::Texture *result = 0 ;
21404
21405   {
21406     try {
21407       result = (Dali::Texture *)new Dali::Texture();
21408     } catch (std::out_of_range& e) {
21409       {
21410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21411       };
21412     } catch (std::exception& e) {
21413       {
21414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21415       };
21416     } catch (...) {
21417       {
21418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21419       };
21420     }
21421   }
21422   jresult = (void *)result;
21423   return jresult;
21424 }
21425
21426
21427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21428   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21429
21430   arg1 = (Dali::Texture *)jarg1;
21431   {
21432     try {
21433       delete arg1;
21434     } catch (std::out_of_range& e) {
21435       {
21436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21437       };
21438     } catch (std::exception& e) {
21439       {
21440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21441       };
21442     } catch (...) {
21443       {
21444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21445       };
21446     }
21447   }
21448 }
21449
21450
21451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21452   void * jresult ;
21453   Dali::Texture *arg1 = 0 ;
21454   Dali::Texture *result = 0 ;
21455
21456   arg1 = (Dali::Texture *)jarg1;
21457   if (!arg1) {
21458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21459     return 0;
21460   }
21461   {
21462     try {
21463       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21464     } catch (std::out_of_range& e) {
21465       {
21466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21467       };
21468     } catch (std::exception& e) {
21469       {
21470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21471       };
21472     } catch (...) {
21473       {
21474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21475       };
21476     }
21477   }
21478   jresult = (void *)result;
21479   return jresult;
21480 }
21481
21482
21483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21484   void * jresult ;
21485   Dali::BaseHandle arg1 ;
21486   Dali::BaseHandle *argp1 ;
21487   Dali::Texture result;
21488
21489   argp1 = (Dali::BaseHandle *)jarg1;
21490   if (!argp1) {
21491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21492     return 0;
21493   }
21494   arg1 = *argp1;
21495   {
21496     try {
21497       result = Dali::Texture::DownCast(arg1);
21498     } catch (std::out_of_range& e) {
21499       {
21500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21501       };
21502     } catch (std::exception& e) {
21503       {
21504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21505       };
21506     } catch (...) {
21507       {
21508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21509       };
21510     }
21511   }
21512   jresult = new Dali::Texture((const Dali::Texture &)result);
21513   return jresult;
21514 }
21515
21516
21517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21518   void * jresult ;
21519   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21520   Dali::Texture *arg2 = 0 ;
21521   Dali::Texture *result = 0 ;
21522
21523   arg1 = (Dali::Texture *)jarg1;
21524   arg2 = (Dali::Texture *)jarg2;
21525   if (!arg2) {
21526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21527     return 0;
21528   }
21529   {
21530     try {
21531       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21532     } catch (std::out_of_range& e) {
21533       {
21534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21535       };
21536     } catch (std::exception& e) {
21537       {
21538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21539       };
21540     } catch (...) {
21541       {
21542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21543       };
21544     }
21545   }
21546   jresult = (void *)result;
21547   return jresult;
21548 }
21549
21550
21551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21552   unsigned int jresult ;
21553   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21554   Dali::PixelData arg2 ;
21555   Dali::PixelData *argp2 ;
21556   bool result;
21557
21558   arg1 = (Dali::Texture *)jarg1;
21559   argp2 = (Dali::PixelData *)jarg2;
21560   if (!argp2) {
21561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21562     return 0;
21563   }
21564   arg2 = *argp2;
21565   {
21566     try {
21567       result = (bool)(arg1)->Upload(arg2);
21568     } catch (std::out_of_range& e) {
21569       {
21570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21571       };
21572     } catch (std::exception& e) {
21573       {
21574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21575       };
21576     } catch (...) {
21577       {
21578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21579       };
21580     }
21581   }
21582   jresult = result;
21583   return jresult;
21584 }
21585
21586
21587 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) {
21588   unsigned int jresult ;
21589   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21590   Dali::PixelData arg2 ;
21591   unsigned int arg3 ;
21592   unsigned int arg4 ;
21593   unsigned int arg5 ;
21594   unsigned int arg6 ;
21595   unsigned int arg7 ;
21596   unsigned int arg8 ;
21597   Dali::PixelData *argp2 ;
21598   bool result;
21599
21600   arg1 = (Dali::Texture *)jarg1;
21601   argp2 = (Dali::PixelData *)jarg2;
21602   if (!argp2) {
21603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21604     return 0;
21605   }
21606   arg2 = *argp2;
21607   arg3 = (unsigned int)jarg3;
21608   arg4 = (unsigned int)jarg4;
21609   arg5 = (unsigned int)jarg5;
21610   arg6 = (unsigned int)jarg6;
21611   arg7 = (unsigned int)jarg7;
21612   arg8 = (unsigned int)jarg8;
21613   {
21614     try {
21615       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21616     } catch (std::out_of_range& e) {
21617       {
21618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21619       };
21620     } catch (std::exception& e) {
21621       {
21622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21623       };
21624     } catch (...) {
21625       {
21626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21627       };
21628     }
21629   }
21630   jresult = result;
21631   return jresult;
21632 }
21633
21634
21635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21636   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21637
21638   arg1 = (Dali::Texture *)jarg1;
21639   {
21640     try {
21641       (arg1)->GenerateMipmaps();
21642     } catch (std::out_of_range& e) {
21643       {
21644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21645       };
21646     } catch (std::exception& e) {
21647       {
21648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21649       };
21650     } catch (...) {
21651       {
21652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21653       };
21654     }
21655   }
21656 }
21657
21658
21659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21660   unsigned int jresult ;
21661   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21662   unsigned int result;
21663
21664   arg1 = (Dali::Texture *)jarg1;
21665   {
21666     try {
21667       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21668     } catch (std::out_of_range& e) {
21669       {
21670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21671       };
21672     } catch (std::exception& e) {
21673       {
21674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21675       };
21676     } catch (...) {
21677       {
21678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21679       };
21680     }
21681   }
21682   jresult = result;
21683   return jresult;
21684 }
21685
21686
21687 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21688   unsigned int jresult ;
21689   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21690   unsigned int result;
21691
21692   arg1 = (Dali::Texture *)jarg1;
21693   {
21694     try {
21695       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
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_new_Texture__SWIG_2(void * jarg1) {
21716   void * jresult ;
21717   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21718   Dali::Texture *result = 0 ;
21719
21720   arg1 = (Dali::Internal::Texture *)jarg1;
21721   {
21722     try {
21723       result = (Dali::Texture *)new Dali::Texture(arg1);
21724     } catch (std::out_of_range& e) {
21725       {
21726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21727       };
21728     } catch (std::exception& e) {
21729       {
21730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21731       };
21732     } catch (...) {
21733       {
21734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21735       };
21736     }
21737   }
21738   jresult = (void *)result;
21739   return jresult;
21740 }
21741
21742
21743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21744   void * jresult ;
21745   Dali::Sampler result;
21746
21747   {
21748     try {
21749       result = Dali::Sampler::New();
21750     } catch (std::out_of_range& e) {
21751       {
21752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21753       };
21754     } catch (std::exception& e) {
21755       {
21756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21757       };
21758     } catch (...) {
21759       {
21760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21761       };
21762     }
21763   }
21764   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21765   return jresult;
21766 }
21767
21768
21769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21770   void * jresult ;
21771   Dali::Sampler *result = 0 ;
21772
21773   {
21774     try {
21775       result = (Dali::Sampler *)new Dali::Sampler();
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 = (void *)result;
21791   return jresult;
21792 }
21793
21794
21795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21796   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21797
21798   arg1 = (Dali::Sampler *)jarg1;
21799   {
21800     try {
21801       delete arg1;
21802     } catch (std::out_of_range& e) {
21803       {
21804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21805       };
21806     } catch (std::exception& e) {
21807       {
21808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21809       };
21810     } catch (...) {
21811       {
21812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21813       };
21814     }
21815   }
21816 }
21817
21818
21819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21820   void * jresult ;
21821   Dali::Sampler *arg1 = 0 ;
21822   Dali::Sampler *result = 0 ;
21823
21824   arg1 = (Dali::Sampler *)jarg1;
21825   if (!arg1) {
21826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21827     return 0;
21828   }
21829   {
21830     try {
21831       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21832     } catch (std::out_of_range& e) {
21833       {
21834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21835       };
21836     } catch (std::exception& e) {
21837       {
21838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21839       };
21840     } catch (...) {
21841       {
21842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21843       };
21844     }
21845   }
21846   jresult = (void *)result;
21847   return jresult;
21848 }
21849
21850
21851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21852   void * jresult ;
21853   Dali::BaseHandle arg1 ;
21854   Dali::BaseHandle *argp1 ;
21855   Dali::Sampler result;
21856
21857   argp1 = (Dali::BaseHandle *)jarg1;
21858   if (!argp1) {
21859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21860     return 0;
21861   }
21862   arg1 = *argp1;
21863   {
21864     try {
21865       result = Dali::Sampler::DownCast(arg1);
21866     } catch (std::out_of_range& e) {
21867       {
21868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21869       };
21870     } catch (std::exception& e) {
21871       {
21872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21873       };
21874     } catch (...) {
21875       {
21876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21877       };
21878     }
21879   }
21880   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21881   return jresult;
21882 }
21883
21884
21885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21886   void * jresult ;
21887   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21888   Dali::Sampler *arg2 = 0 ;
21889   Dali::Sampler *result = 0 ;
21890
21891   arg1 = (Dali::Sampler *)jarg1;
21892   arg2 = (Dali::Sampler *)jarg2;
21893   if (!arg2) {
21894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21895     return 0;
21896   }
21897   {
21898     try {
21899       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
21900     } catch (std::out_of_range& e) {
21901       {
21902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21903       };
21904     } catch (std::exception& e) {
21905       {
21906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21907       };
21908     } catch (...) {
21909       {
21910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21911       };
21912     }
21913   }
21914   jresult = (void *)result;
21915   return jresult;
21916 }
21917
21918
21919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
21920   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21921   Dali::FilterMode::Type arg2 ;
21922   Dali::FilterMode::Type arg3 ;
21923
21924   arg1 = (Dali::Sampler *)jarg1;
21925   arg2 = (Dali::FilterMode::Type)jarg2;
21926   arg3 = (Dali::FilterMode::Type)jarg3;
21927   {
21928     try {
21929       (arg1)->SetFilterMode(arg2,arg3);
21930     } catch (std::out_of_range& e) {
21931       {
21932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21933       };
21934     } catch (std::exception& e) {
21935       {
21936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21937       };
21938     } catch (...) {
21939       {
21940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21941       };
21942     }
21943   }
21944 }
21945
21946
21947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
21948   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21949   Dali::WrapMode::Type arg2 ;
21950   Dali::WrapMode::Type arg3 ;
21951
21952   arg1 = (Dali::Sampler *)jarg1;
21953   arg2 = (Dali::WrapMode::Type)jarg2;
21954   arg3 = (Dali::WrapMode::Type)jarg3;
21955   {
21956     try {
21957       (arg1)->SetWrapMode(arg2,arg3);
21958     } catch (std::out_of_range& e) {
21959       {
21960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21961       };
21962     } catch (std::exception& e) {
21963       {
21964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21965       };
21966     } catch (...) {
21967       {
21968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21969       };
21970     }
21971   }
21972 }
21973
21974
21975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
21976   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21977   Dali::WrapMode::Type arg2 ;
21978   Dali::WrapMode::Type arg3 ;
21979   Dali::WrapMode::Type arg4 ;
21980
21981   arg1 = (Dali::Sampler *)jarg1;
21982   arg2 = (Dali::WrapMode::Type)jarg2;
21983   arg3 = (Dali::WrapMode::Type)jarg3;
21984   arg4 = (Dali::WrapMode::Type)jarg4;
21985   {
21986     try {
21987       (arg1)->SetWrapMode(arg2,arg3,arg4);
21988     } catch (std::out_of_range& e) {
21989       {
21990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21991       };
21992     } catch (std::exception& e) {
21993       {
21994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21995       };
21996     } catch (...) {
21997       {
21998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21999       };
22000     }
22001   }
22002 }
22003
22004
22005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22006   void * jresult ;
22007   Dali::TextureSet result;
22008
22009   {
22010     try {
22011       result = Dali::TextureSet::New();
22012     } catch (std::out_of_range& e) {
22013       {
22014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22015       };
22016     } catch (std::exception& e) {
22017       {
22018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22019       };
22020     } catch (...) {
22021       {
22022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22023       };
22024     }
22025   }
22026   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22027   return jresult;
22028 }
22029
22030
22031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22032   void * jresult ;
22033   Dali::TextureSet *result = 0 ;
22034
22035   {
22036     try {
22037       result = (Dali::TextureSet *)new Dali::TextureSet();
22038     } catch (std::out_of_range& e) {
22039       {
22040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22041       };
22042     } catch (std::exception& e) {
22043       {
22044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22045       };
22046     } catch (...) {
22047       {
22048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22049       };
22050     }
22051   }
22052   jresult = (void *)result;
22053   return jresult;
22054 }
22055
22056
22057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22058   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22059
22060   arg1 = (Dali::TextureSet *)jarg1;
22061   {
22062     try {
22063       delete arg1;
22064     } catch (std::out_of_range& e) {
22065       {
22066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22067       };
22068     } catch (std::exception& e) {
22069       {
22070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22071       };
22072     } catch (...) {
22073       {
22074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22075       };
22076     }
22077   }
22078 }
22079
22080
22081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22082   void * jresult ;
22083   Dali::TextureSet *arg1 = 0 ;
22084   Dali::TextureSet *result = 0 ;
22085
22086   arg1 = (Dali::TextureSet *)jarg1;
22087   if (!arg1) {
22088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22089     return 0;
22090   }
22091   {
22092     try {
22093       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22094     } catch (std::out_of_range& e) {
22095       {
22096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22097       };
22098     } catch (std::exception& e) {
22099       {
22100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22101       };
22102     } catch (...) {
22103       {
22104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22105       };
22106     }
22107   }
22108   jresult = (void *)result;
22109   return jresult;
22110 }
22111
22112
22113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22114   void * jresult ;
22115   Dali::BaseHandle arg1 ;
22116   Dali::BaseHandle *argp1 ;
22117   Dali::TextureSet result;
22118
22119   argp1 = (Dali::BaseHandle *)jarg1;
22120   if (!argp1) {
22121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22122     return 0;
22123   }
22124   arg1 = *argp1;
22125   {
22126     try {
22127       result = Dali::TextureSet::DownCast(arg1);
22128     } catch (std::out_of_range& e) {
22129       {
22130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22131       };
22132     } catch (std::exception& e) {
22133       {
22134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22135       };
22136     } catch (...) {
22137       {
22138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22139       };
22140     }
22141   }
22142   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22143   return jresult;
22144 }
22145
22146
22147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22148   void * jresult ;
22149   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22150   Dali::TextureSet *arg2 = 0 ;
22151   Dali::TextureSet *result = 0 ;
22152
22153   arg1 = (Dali::TextureSet *)jarg1;
22154   arg2 = (Dali::TextureSet *)jarg2;
22155   if (!arg2) {
22156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22157     return 0;
22158   }
22159   {
22160     try {
22161       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22162     } catch (std::out_of_range& e) {
22163       {
22164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22165       };
22166     } catch (std::exception& e) {
22167       {
22168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22169       };
22170     } catch (...) {
22171       {
22172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22173       };
22174     }
22175   }
22176   jresult = (void *)result;
22177   return jresult;
22178 }
22179
22180
22181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22182   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22183   size_t arg2 ;
22184   Dali::Texture arg3 ;
22185   Dali::Texture *argp3 ;
22186
22187   arg1 = (Dali::TextureSet *)jarg1;
22188   arg2 = (size_t)jarg2;
22189   argp3 = (Dali::Texture *)jarg3;
22190   if (!argp3) {
22191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22192     return ;
22193   }
22194   arg3 = *argp3;
22195   {
22196     try {
22197       (arg1)->SetTexture(arg2,arg3);
22198     } catch (std::out_of_range& e) {
22199       {
22200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22201       };
22202     } catch (std::exception& e) {
22203       {
22204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22205       };
22206     } catch (...) {
22207       {
22208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22209       };
22210     }
22211   }
22212 }
22213
22214
22215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22216   void * jresult ;
22217   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22218   size_t arg2 ;
22219   Dali::Texture result;
22220
22221   arg1 = (Dali::TextureSet *)jarg1;
22222   arg2 = (size_t)jarg2;
22223   {
22224     try {
22225       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22226     } catch (std::out_of_range& e) {
22227       {
22228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22229       };
22230     } catch (std::exception& e) {
22231       {
22232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22233       };
22234     } catch (...) {
22235       {
22236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22237       };
22238     }
22239   }
22240   jresult = new Dali::Texture((const Dali::Texture &)result);
22241   return jresult;
22242 }
22243
22244
22245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22246   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22247   size_t arg2 ;
22248   Dali::Sampler arg3 ;
22249   Dali::Sampler *argp3 ;
22250
22251   arg1 = (Dali::TextureSet *)jarg1;
22252   arg2 = (size_t)jarg2;
22253   argp3 = (Dali::Sampler *)jarg3;
22254   if (!argp3) {
22255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22256     return ;
22257   }
22258   arg3 = *argp3;
22259   {
22260     try {
22261       (arg1)->SetSampler(arg2,arg3);
22262     } catch (std::out_of_range& e) {
22263       {
22264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22265       };
22266     } catch (std::exception& e) {
22267       {
22268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22269       };
22270     } catch (...) {
22271       {
22272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22273       };
22274     }
22275   }
22276 }
22277
22278
22279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22280   void * jresult ;
22281   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22282   size_t arg2 ;
22283   Dali::Sampler result;
22284
22285   arg1 = (Dali::TextureSet *)jarg1;
22286   arg2 = (size_t)jarg2;
22287   {
22288     try {
22289       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22290     } catch (std::out_of_range& e) {
22291       {
22292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22293       };
22294     } catch (std::exception& e) {
22295       {
22296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22297       };
22298     } catch (...) {
22299       {
22300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22301       };
22302     }
22303   }
22304   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22305   return jresult;
22306 }
22307
22308
22309 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22310   unsigned long jresult ;
22311   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22312   size_t result;
22313
22314   arg1 = (Dali::TextureSet *)jarg1;
22315   {
22316     try {
22317       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22318     } catch (std::out_of_range& e) {
22319       {
22320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22321       };
22322     } catch (std::exception& e) {
22323       {
22324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22325       };
22326     } catch (...) {
22327       {
22328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22329       };
22330     }
22331   }
22332   jresult = (unsigned long)result;
22333   return jresult;
22334 }
22335
22336
22337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22338   void * jresult ;
22339   Dali::Property::Map *arg1 = 0 ;
22340   Dali::PropertyBuffer result;
22341
22342   arg1 = (Dali::Property::Map *)jarg1;
22343   if (!arg1) {
22344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22345     return 0;
22346   }
22347   {
22348     try {
22349       result = Dali::PropertyBuffer::New(*arg1);
22350     } catch (std::out_of_range& e) {
22351       {
22352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22353       };
22354     } catch (std::exception& e) {
22355       {
22356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22357       };
22358     } catch (...) {
22359       {
22360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22361       };
22362     }
22363   }
22364   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22365   return jresult;
22366 }
22367
22368
22369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22370   void * jresult ;
22371   Dali::PropertyBuffer *result = 0 ;
22372
22373   {
22374     try {
22375       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22376     } catch (std::out_of_range& e) {
22377       {
22378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22379       };
22380     } catch (std::exception& e) {
22381       {
22382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22383       };
22384     } catch (...) {
22385       {
22386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22387       };
22388     }
22389   }
22390   jresult = (void *)result;
22391   return jresult;
22392 }
22393
22394
22395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22396   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22397
22398   arg1 = (Dali::PropertyBuffer *)jarg1;
22399   {
22400     try {
22401       delete arg1;
22402     } catch (std::out_of_range& e) {
22403       {
22404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22405       };
22406     } catch (std::exception& e) {
22407       {
22408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22409       };
22410     } catch (...) {
22411       {
22412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22413       };
22414     }
22415   }
22416 }
22417
22418
22419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22420   void * jresult ;
22421   Dali::PropertyBuffer *arg1 = 0 ;
22422   Dali::PropertyBuffer *result = 0 ;
22423
22424   arg1 = (Dali::PropertyBuffer *)jarg1;
22425   if (!arg1) {
22426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22427     return 0;
22428   }
22429   {
22430     try {
22431       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22432     } catch (std::out_of_range& e) {
22433       {
22434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22435       };
22436     } catch (std::exception& e) {
22437       {
22438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22439       };
22440     } catch (...) {
22441       {
22442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22443       };
22444     }
22445   }
22446   jresult = (void *)result;
22447   return jresult;
22448 }
22449
22450
22451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22452   void * jresult ;
22453   Dali::BaseHandle arg1 ;
22454   Dali::BaseHandle *argp1 ;
22455   Dali::PropertyBuffer result;
22456
22457   argp1 = (Dali::BaseHandle *)jarg1;
22458   if (!argp1) {
22459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22460     return 0;
22461   }
22462   arg1 = *argp1;
22463   {
22464     try {
22465       result = Dali::PropertyBuffer::DownCast(arg1);
22466     } catch (std::out_of_range& e) {
22467       {
22468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22469       };
22470     } catch (std::exception& e) {
22471       {
22472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22473       };
22474     } catch (...) {
22475       {
22476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22477       };
22478     }
22479   }
22480   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22481   return jresult;
22482 }
22483
22484
22485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22486   void * jresult ;
22487   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22488   Dali::PropertyBuffer *arg2 = 0 ;
22489   Dali::PropertyBuffer *result = 0 ;
22490
22491   arg1 = (Dali::PropertyBuffer *)jarg1;
22492   arg2 = (Dali::PropertyBuffer *)jarg2;
22493   if (!arg2) {
22494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22495     return 0;
22496   }
22497   {
22498     try {
22499       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22500     } catch (std::out_of_range& e) {
22501       {
22502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22503       };
22504     } catch (std::exception& e) {
22505       {
22506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22507       };
22508     } catch (...) {
22509       {
22510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22511       };
22512     }
22513   }
22514   jresult = (void *)result;
22515   return jresult;
22516 }
22517
22518
22519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22520   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22521   void *arg2 = (void *) 0 ;
22522   std::size_t arg3 ;
22523
22524   arg1 = (Dali::PropertyBuffer *)jarg1;
22525   arg2 = jarg2;
22526   arg3 = (std::size_t)jarg3;
22527   {
22528     try {
22529       (arg1)->SetData((void const *)arg2,arg3);
22530     } catch (std::out_of_range& e) {
22531       {
22532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22533       };
22534     } catch (std::exception& e) {
22535       {
22536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22537       };
22538     } catch (...) {
22539       {
22540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22541       };
22542     }
22543   }
22544 }
22545
22546
22547 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22548   unsigned long jresult ;
22549   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22550   std::size_t result;
22551
22552   arg1 = (Dali::PropertyBuffer *)jarg1;
22553   {
22554     try {
22555       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22556     } catch (std::out_of_range& e) {
22557       {
22558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22559       };
22560     } catch (std::exception& e) {
22561       {
22562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22563       };
22564     } catch (...) {
22565       {
22566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22567       };
22568     }
22569   }
22570   jresult = (unsigned long)result;
22571   return jresult;
22572 }
22573
22574
22575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22576   void * jresult ;
22577   Dali::Geometry result;
22578
22579   {
22580     try {
22581       result = Dali::Geometry::New();
22582     } catch (std::out_of_range& e) {
22583       {
22584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22585       };
22586     } catch (std::exception& e) {
22587       {
22588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22589       };
22590     } catch (...) {
22591       {
22592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22593       };
22594     }
22595   }
22596   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22597   return jresult;
22598 }
22599
22600
22601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22602   void * jresult ;
22603   Dali::Geometry *result = 0 ;
22604
22605   {
22606     try {
22607       result = (Dali::Geometry *)new Dali::Geometry();
22608     } catch (std::out_of_range& e) {
22609       {
22610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22611       };
22612     } catch (std::exception& e) {
22613       {
22614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22615       };
22616     } catch (...) {
22617       {
22618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22619       };
22620     }
22621   }
22622   jresult = (void *)result;
22623   return jresult;
22624 }
22625
22626
22627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22628   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22629
22630   arg1 = (Dali::Geometry *)jarg1;
22631   {
22632     try {
22633       delete arg1;
22634     } catch (std::out_of_range& e) {
22635       {
22636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22637       };
22638     } catch (std::exception& e) {
22639       {
22640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22641       };
22642     } catch (...) {
22643       {
22644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22645       };
22646     }
22647   }
22648 }
22649
22650
22651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22652   void * jresult ;
22653   Dali::Geometry *arg1 = 0 ;
22654   Dali::Geometry *result = 0 ;
22655
22656   arg1 = (Dali::Geometry *)jarg1;
22657   if (!arg1) {
22658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22659     return 0;
22660   }
22661   {
22662     try {
22663       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22664     } catch (std::out_of_range& e) {
22665       {
22666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22667       };
22668     } catch (std::exception& e) {
22669       {
22670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22671       };
22672     } catch (...) {
22673       {
22674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22675       };
22676     }
22677   }
22678   jresult = (void *)result;
22679   return jresult;
22680 }
22681
22682
22683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22684   void * jresult ;
22685   Dali::BaseHandle arg1 ;
22686   Dali::BaseHandle *argp1 ;
22687   Dali::Geometry result;
22688
22689   argp1 = (Dali::BaseHandle *)jarg1;
22690   if (!argp1) {
22691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22692     return 0;
22693   }
22694   arg1 = *argp1;
22695   {
22696     try {
22697       result = Dali::Geometry::DownCast(arg1);
22698     } catch (std::out_of_range& e) {
22699       {
22700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22701       };
22702     } catch (std::exception& e) {
22703       {
22704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22705       };
22706     } catch (...) {
22707       {
22708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22709       };
22710     }
22711   }
22712   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22713   return jresult;
22714 }
22715
22716
22717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22718   void * jresult ;
22719   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22720   Dali::Geometry *arg2 = 0 ;
22721   Dali::Geometry *result = 0 ;
22722
22723   arg1 = (Dali::Geometry *)jarg1;
22724   arg2 = (Dali::Geometry *)jarg2;
22725   if (!arg2) {
22726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22727     return 0;
22728   }
22729   {
22730     try {
22731       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22732     } catch (std::out_of_range& e) {
22733       {
22734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22735       };
22736     } catch (std::exception& e) {
22737       {
22738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22739       };
22740     } catch (...) {
22741       {
22742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22743       };
22744     }
22745   }
22746   jresult = (void *)result;
22747   return jresult;
22748 }
22749
22750
22751 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22752   unsigned long jresult ;
22753   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22754   Dali::PropertyBuffer *arg2 = 0 ;
22755   std::size_t result;
22756
22757   arg1 = (Dali::Geometry *)jarg1;
22758   arg2 = (Dali::PropertyBuffer *)jarg2;
22759   if (!arg2) {
22760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22761     return 0;
22762   }
22763   {
22764     try {
22765       result = (arg1)->AddVertexBuffer(*arg2);
22766     } catch (std::out_of_range& e) {
22767       {
22768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22769       };
22770     } catch (std::exception& e) {
22771       {
22772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22773       };
22774     } catch (...) {
22775       {
22776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22777       };
22778     }
22779   }
22780   jresult = (unsigned long)result;
22781   return jresult;
22782 }
22783
22784
22785 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22786   unsigned long jresult ;
22787   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22788   std::size_t result;
22789
22790   arg1 = (Dali::Geometry *)jarg1;
22791   {
22792     try {
22793       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22794     } catch (std::out_of_range& e) {
22795       {
22796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22797       };
22798     } catch (std::exception& e) {
22799       {
22800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22801       };
22802     } catch (...) {
22803       {
22804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22805       };
22806     }
22807   }
22808   jresult = (unsigned long)result;
22809   return jresult;
22810 }
22811
22812
22813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22814   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22815   std::size_t arg2 ;
22816
22817   arg1 = (Dali::Geometry *)jarg1;
22818   arg2 = (std::size_t)jarg2;
22819   {
22820     try {
22821       (arg1)->RemoveVertexBuffer(arg2);
22822     } catch (std::out_of_range& e) {
22823       {
22824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22825       };
22826     } catch (std::exception& e) {
22827       {
22828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22829       };
22830     } catch (...) {
22831       {
22832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22833       };
22834     }
22835   }
22836 }
22837
22838
22839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22840   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22841   unsigned short *arg2 = (unsigned short *) 0 ;
22842   size_t arg3 ;
22843
22844   arg1 = (Dali::Geometry *)jarg1;
22845   arg2 = jarg2;
22846   arg3 = (size_t)jarg3;
22847   {
22848     try {
22849       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22850     } catch (std::out_of_range& e) {
22851       {
22852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22853       };
22854     } catch (std::exception& e) {
22855       {
22856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22857       };
22858     } catch (...) {
22859       {
22860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22861       };
22862     }
22863   }
22864
22865
22866 }
22867
22868
22869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22870   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22871   Dali::Geometry::Type arg2 ;
22872
22873   arg1 = (Dali::Geometry *)jarg1;
22874   arg2 = (Dali::Geometry::Type)jarg2;
22875   {
22876     try {
22877       (arg1)->SetType(arg2);
22878     } catch (std::out_of_range& e) {
22879       {
22880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22881       };
22882     } catch (std::exception& e) {
22883       {
22884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22885       };
22886     } catch (...) {
22887       {
22888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22889       };
22890     }
22891   }
22892 }
22893
22894
22895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22896   int jresult ;
22897   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22898   Dali::Geometry::Type result;
22899
22900   arg1 = (Dali::Geometry *)jarg1;
22901   {
22902     try {
22903       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
22904     } catch (std::out_of_range& e) {
22905       {
22906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22907       };
22908     } catch (std::exception& e) {
22909       {
22910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22911       };
22912     } catch (...) {
22913       {
22914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22915       };
22916     }
22917   }
22918   jresult = (int)result;
22919   return jresult;
22920 }
22921
22922
22923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
22924   void * jresult ;
22925   Dali::Shader::Hint *result = 0 ;
22926
22927   {
22928     try {
22929       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
22930     } catch (std::out_of_range& e) {
22931       {
22932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22933       };
22934     } catch (std::exception& e) {
22935       {
22936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22937       };
22938     } catch (...) {
22939       {
22940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22941       };
22942     }
22943   }
22944   jresult = (void *)result;
22945   return jresult;
22946 }
22947
22948
22949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
22950   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
22951
22952   arg1 = (Dali::Shader::Hint *)jarg1;
22953   {
22954     try {
22955       delete arg1;
22956     } catch (std::out_of_range& e) {
22957       {
22958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22959       };
22960     } catch (std::exception& e) {
22961       {
22962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22963       };
22964     } catch (...) {
22965       {
22966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22967       };
22968     }
22969   }
22970 }
22971
22972
22973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
22974   int jresult ;
22975   int result;
22976
22977   result = (int)Dali::Shader::Property::PROGRAM;
22978   jresult = (int)result;
22979   return jresult;
22980 }
22981
22982
22983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
22984   void * jresult ;
22985   Dali::Shader::Property *result = 0 ;
22986
22987   {
22988     try {
22989       result = (Dali::Shader::Property *)new Dali::Shader::Property();
22990     } catch (std::out_of_range& e) {
22991       {
22992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22993       };
22994     } catch (std::exception& e) {
22995       {
22996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22997       };
22998     } catch (...) {
22999       {
23000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23001       };
23002     }
23003   }
23004   jresult = (void *)result;
23005   return jresult;
23006 }
23007
23008
23009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23010   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23011
23012   arg1 = (Dali::Shader::Property *)jarg1;
23013   {
23014     try {
23015       delete arg1;
23016     } catch (std::out_of_range& e) {
23017       {
23018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23019       };
23020     } catch (std::exception& e) {
23021       {
23022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23023       };
23024     } catch (...) {
23025       {
23026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23027       };
23028     }
23029   }
23030 }
23031
23032
23033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23034   void * jresult ;
23035   std::string *arg1 = 0 ;
23036   std::string *arg2 = 0 ;
23037   Dali::Shader::Hint::Value arg3 ;
23038   Dali::Shader result;
23039
23040   if (!jarg1) {
23041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23042     return 0;
23043   }
23044   std::string arg1_str(jarg1);
23045   arg1 = &arg1_str;
23046   if (!jarg2) {
23047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23048     return 0;
23049   }
23050   std::string arg2_str(jarg2);
23051   arg2 = &arg2_str;
23052   arg3 = (Dali::Shader::Hint::Value)jarg3;
23053   {
23054     try {
23055       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23056     } catch (std::out_of_range& e) {
23057       {
23058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23059       };
23060     } catch (std::exception& e) {
23061       {
23062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23063       };
23064     } catch (...) {
23065       {
23066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23067       };
23068     }
23069   }
23070   jresult = new Dali::Shader((const Dali::Shader &)result);
23071
23072   //argout typemap for const std::string&
23073
23074
23075   //argout typemap for const std::string&
23076
23077   return jresult;
23078 }
23079
23080
23081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23082   void * jresult ;
23083   std::string *arg1 = 0 ;
23084   std::string *arg2 = 0 ;
23085   Dali::Shader result;
23086
23087   if (!jarg1) {
23088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23089     return 0;
23090   }
23091   std::string arg1_str(jarg1);
23092   arg1 = &arg1_str;
23093   if (!jarg2) {
23094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23095     return 0;
23096   }
23097   std::string arg2_str(jarg2);
23098   arg2 = &arg2_str;
23099   {
23100     try {
23101       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23102     } catch (std::out_of_range& e) {
23103       {
23104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23105       };
23106     } catch (std::exception& e) {
23107       {
23108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23109       };
23110     } catch (...) {
23111       {
23112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23113       };
23114     }
23115   }
23116   jresult = new Dali::Shader((const Dali::Shader &)result);
23117
23118   //argout typemap for const std::string&
23119
23120
23121   //argout typemap for const std::string&
23122
23123   return jresult;
23124 }
23125
23126
23127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23128   void * jresult ;
23129   Dali::Shader *result = 0 ;
23130
23131   {
23132     try {
23133       result = (Dali::Shader *)new Dali::Shader();
23134     } catch (std::out_of_range& e) {
23135       {
23136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23137       };
23138     } catch (std::exception& e) {
23139       {
23140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23141       };
23142     } catch (...) {
23143       {
23144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23145       };
23146     }
23147   }
23148   jresult = (void *)result;
23149   return jresult;
23150 }
23151
23152
23153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23154   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23155
23156   arg1 = (Dali::Shader *)jarg1;
23157   {
23158     try {
23159       delete arg1;
23160     } catch (std::out_of_range& e) {
23161       {
23162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23163       };
23164     } catch (std::exception& e) {
23165       {
23166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23167       };
23168     } catch (...) {
23169       {
23170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23171       };
23172     }
23173   }
23174 }
23175
23176
23177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23178   void * jresult ;
23179   Dali::Shader *arg1 = 0 ;
23180   Dali::Shader *result = 0 ;
23181
23182   arg1 = (Dali::Shader *)jarg1;
23183   if (!arg1) {
23184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23185     return 0;
23186   }
23187   {
23188     try {
23189       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23190     } catch (std::out_of_range& e) {
23191       {
23192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23193       };
23194     } catch (std::exception& e) {
23195       {
23196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23197       };
23198     } catch (...) {
23199       {
23200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23201       };
23202     }
23203   }
23204   jresult = (void *)result;
23205   return jresult;
23206 }
23207
23208
23209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23210   void * jresult ;
23211   Dali::BaseHandle arg1 ;
23212   Dali::BaseHandle *argp1 ;
23213   Dali::Shader result;
23214
23215   argp1 = (Dali::BaseHandle *)jarg1;
23216   if (!argp1) {
23217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23218     return 0;
23219   }
23220   arg1 = *argp1;
23221   {
23222     try {
23223       result = Dali::Shader::DownCast(arg1);
23224     } catch (std::out_of_range& e) {
23225       {
23226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23227       };
23228     } catch (std::exception& e) {
23229       {
23230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23231       };
23232     } catch (...) {
23233       {
23234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23235       };
23236     }
23237   }
23238   jresult = new Dali::Shader((const Dali::Shader &)result);
23239   return jresult;
23240 }
23241
23242
23243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23244   void * jresult ;
23245   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23246   Dali::Shader *arg2 = 0 ;
23247   Dali::Shader *result = 0 ;
23248
23249   arg1 = (Dali::Shader *)jarg1;
23250   arg2 = (Dali::Shader *)jarg2;
23251   if (!arg2) {
23252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23253     return 0;
23254   }
23255   {
23256     try {
23257       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23258     } catch (std::out_of_range& e) {
23259       {
23260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23261       };
23262     } catch (std::exception& e) {
23263       {
23264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23265       };
23266     } catch (...) {
23267       {
23268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23269       };
23270     }
23271   }
23272   jresult = (void *)result;
23273   return jresult;
23274 }
23275
23276
23277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23278   int jresult ;
23279   int result;
23280
23281   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23282   jresult = (int)result;
23283   return jresult;
23284 }
23285
23286
23287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23288   int jresult ;
23289   int result;
23290
23291   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23292   jresult = (int)result;
23293   return jresult;
23294 }
23295
23296
23297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23298   int jresult ;
23299   int result;
23300
23301   result = (int)Dali::Renderer::Property::BLEND_MODE;
23302   jresult = (int)result;
23303   return jresult;
23304 }
23305
23306
23307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23308   int jresult ;
23309   int result;
23310
23311   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23312   jresult = (int)result;
23313   return jresult;
23314 }
23315
23316
23317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23318   int jresult ;
23319   int result;
23320
23321   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23322   jresult = (int)result;
23323   return jresult;
23324 }
23325
23326
23327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23328   int jresult ;
23329   int result;
23330
23331   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23332   jresult = (int)result;
23333   return jresult;
23334 }
23335
23336
23337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23338   int jresult ;
23339   int result;
23340
23341   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23342   jresult = (int)result;
23343   return jresult;
23344 }
23345
23346
23347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23348   int jresult ;
23349   int result;
23350
23351   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23352   jresult = (int)result;
23353   return jresult;
23354 }
23355
23356
23357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23358   int jresult ;
23359   int result;
23360
23361   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23362   jresult = (int)result;
23363   return jresult;
23364 }
23365
23366
23367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23368   int jresult ;
23369   int result;
23370
23371   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23372   jresult = (int)result;
23373   return jresult;
23374 }
23375
23376
23377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23378   int jresult ;
23379   int result;
23380
23381   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23382   jresult = (int)result;
23383   return jresult;
23384 }
23385
23386
23387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23388   int jresult ;
23389   int result;
23390
23391   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23392   jresult = (int)result;
23393   return jresult;
23394 }
23395
23396
23397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23398   int jresult ;
23399   int result;
23400
23401   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23402   jresult = (int)result;
23403   return jresult;
23404 }
23405
23406
23407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23408   int jresult ;
23409   int result;
23410
23411   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23412   jresult = (int)result;
23413   return jresult;
23414 }
23415
23416
23417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23418   int jresult ;
23419   int result;
23420
23421   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23422   jresult = (int)result;
23423   return jresult;
23424 }
23425
23426
23427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23428   int jresult ;
23429   int result;
23430
23431   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23432   jresult = (int)result;
23433   return jresult;
23434 }
23435
23436
23437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23438   int jresult ;
23439   int result;
23440
23441   result = (int)Dali::Renderer::Property::RENDER_MODE;
23442   jresult = (int)result;
23443   return jresult;
23444 }
23445
23446
23447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23448   int jresult ;
23449   int result;
23450
23451   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23452   jresult = (int)result;
23453   return jresult;
23454 }
23455
23456
23457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23458   int jresult ;
23459   int result;
23460
23461   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23462   jresult = (int)result;
23463   return jresult;
23464 }
23465
23466
23467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23468   int jresult ;
23469   int result;
23470
23471   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23472   jresult = (int)result;
23473   return jresult;
23474 }
23475
23476
23477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23478   int jresult ;
23479   int result;
23480
23481   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23482   jresult = (int)result;
23483   return jresult;
23484 }
23485
23486
23487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23488   int jresult ;
23489   int result;
23490
23491   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23492   jresult = (int)result;
23493   return jresult;
23494 }
23495
23496
23497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23498   int jresult ;
23499   int result;
23500
23501   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23502   jresult = (int)result;
23503   return jresult;
23504 }
23505
23506
23507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23508   int jresult ;
23509   int result;
23510
23511   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23512   jresult = (int)result;
23513   return jresult;
23514 }
23515
23516
23517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23518   void * jresult ;
23519   Dali::Renderer::Property *result = 0 ;
23520
23521   {
23522     try {
23523       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23524     } catch (std::out_of_range& e) {
23525       {
23526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23527       };
23528     } catch (std::exception& e) {
23529       {
23530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23531       };
23532     } catch (...) {
23533       {
23534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23535       };
23536     }
23537   }
23538   jresult = (void *)result;
23539   return jresult;
23540 }
23541
23542
23543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23544   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23545
23546   arg1 = (Dali::Renderer::Property *)jarg1;
23547   {
23548     try {
23549       delete arg1;
23550     } catch (std::out_of_range& e) {
23551       {
23552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23553       };
23554     } catch (std::exception& e) {
23555       {
23556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23557       };
23558     } catch (...) {
23559       {
23560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23561       };
23562     }
23563   }
23564 }
23565
23566
23567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23568   void * jresult ;
23569   Dali::Geometry *arg1 = 0 ;
23570   Dali::Shader *arg2 = 0 ;
23571   Dali::Renderer result;
23572
23573   arg1 = (Dali::Geometry *)jarg1;
23574   if (!arg1) {
23575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23576     return 0;
23577   }
23578   arg2 = (Dali::Shader *)jarg2;
23579   if (!arg2) {
23580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23581     return 0;
23582   }
23583   {
23584     try {
23585       result = Dali::Renderer::New(*arg1,*arg2);
23586     } catch (std::out_of_range& e) {
23587       {
23588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23589       };
23590     } catch (std::exception& e) {
23591       {
23592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23593       };
23594     } catch (...) {
23595       {
23596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23597       };
23598     }
23599   }
23600   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23601   return jresult;
23602 }
23603
23604
23605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23606   void * jresult ;
23607   Dali::Renderer *result = 0 ;
23608
23609   {
23610     try {
23611       result = (Dali::Renderer *)new Dali::Renderer();
23612     } catch (std::out_of_range& e) {
23613       {
23614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23615       };
23616     } catch (std::exception& e) {
23617       {
23618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23619       };
23620     } catch (...) {
23621       {
23622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23623       };
23624     }
23625   }
23626   jresult = (void *)result;
23627   return jresult;
23628 }
23629
23630
23631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23632   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23633
23634   arg1 = (Dali::Renderer *)jarg1;
23635   {
23636     try {
23637       delete arg1;
23638     } catch (std::out_of_range& e) {
23639       {
23640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23641       };
23642     } catch (std::exception& e) {
23643       {
23644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23645       };
23646     } catch (...) {
23647       {
23648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23649       };
23650     }
23651   }
23652 }
23653
23654
23655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23656   void * jresult ;
23657   Dali::Renderer *arg1 = 0 ;
23658   Dali::Renderer *result = 0 ;
23659
23660   arg1 = (Dali::Renderer *)jarg1;
23661   if (!arg1) {
23662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23663     return 0;
23664   }
23665   {
23666     try {
23667       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23668     } catch (std::out_of_range& e) {
23669       {
23670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23671       };
23672     } catch (std::exception& e) {
23673       {
23674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23675       };
23676     } catch (...) {
23677       {
23678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23679       };
23680     }
23681   }
23682   jresult = (void *)result;
23683   return jresult;
23684 }
23685
23686
23687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23688   void * jresult ;
23689   Dali::BaseHandle arg1 ;
23690   Dali::BaseHandle *argp1 ;
23691   Dali::Renderer result;
23692
23693   argp1 = (Dali::BaseHandle *)jarg1;
23694   if (!argp1) {
23695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23696     return 0;
23697   }
23698   arg1 = *argp1;
23699   {
23700     try {
23701       result = Dali::Renderer::DownCast(arg1);
23702     } catch (std::out_of_range& e) {
23703       {
23704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23705       };
23706     } catch (std::exception& e) {
23707       {
23708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23709       };
23710     } catch (...) {
23711       {
23712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23713       };
23714     }
23715   }
23716   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23717   return jresult;
23718 }
23719
23720
23721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23722   void * jresult ;
23723   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23724   Dali::Renderer *arg2 = 0 ;
23725   Dali::Renderer *result = 0 ;
23726
23727   arg1 = (Dali::Renderer *)jarg1;
23728   arg2 = (Dali::Renderer *)jarg2;
23729   if (!arg2) {
23730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23731     return 0;
23732   }
23733   {
23734     try {
23735       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23736     } catch (std::out_of_range& e) {
23737       {
23738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23739       };
23740     } catch (std::exception& e) {
23741       {
23742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23743       };
23744     } catch (...) {
23745       {
23746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23747       };
23748     }
23749   }
23750   jresult = (void *)result;
23751   return jresult;
23752 }
23753
23754
23755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23756   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23757   Dali::Geometry *arg2 = 0 ;
23758
23759   arg1 = (Dali::Renderer *)jarg1;
23760   arg2 = (Dali::Geometry *)jarg2;
23761   if (!arg2) {
23762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23763     return ;
23764   }
23765   {
23766     try {
23767       (arg1)->SetGeometry(*arg2);
23768     } catch (std::out_of_range& e) {
23769       {
23770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23771       };
23772     } catch (std::exception& e) {
23773       {
23774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23775       };
23776     } catch (...) {
23777       {
23778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23779       };
23780     }
23781   }
23782 }
23783
23784
23785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23786   void * jresult ;
23787   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23788   Dali::Geometry result;
23789
23790   arg1 = (Dali::Renderer *)jarg1;
23791   {
23792     try {
23793       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23794     } catch (std::out_of_range& e) {
23795       {
23796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23797       };
23798     } catch (std::exception& e) {
23799       {
23800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23801       };
23802     } catch (...) {
23803       {
23804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23805       };
23806     }
23807   }
23808   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23809   return jresult;
23810 }
23811
23812
23813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23814   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23815   int arg2 ;
23816   int arg3 ;
23817
23818   arg1 = (Dali::Renderer *)jarg1;
23819   arg2 = (int)jarg2;
23820   arg3 = (int)jarg3;
23821   {
23822     try {
23823       (arg1)->SetIndexRange(arg2,arg3);
23824     } catch (std::out_of_range& e) {
23825       {
23826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23827       };
23828     } catch (std::exception& e) {
23829       {
23830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23831       };
23832     } catch (...) {
23833       {
23834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23835       };
23836     }
23837   }
23838 }
23839
23840
23841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23842   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23843   Dali::TextureSet *arg2 = 0 ;
23844
23845   arg1 = (Dali::Renderer *)jarg1;
23846   arg2 = (Dali::TextureSet *)jarg2;
23847   if (!arg2) {
23848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23849     return ;
23850   }
23851   {
23852     try {
23853       (arg1)->SetTextures(*arg2);
23854     } catch (std::out_of_range& e) {
23855       {
23856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23857       };
23858     } catch (std::exception& e) {
23859       {
23860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23861       };
23862     } catch (...) {
23863       {
23864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23865       };
23866     }
23867   }
23868 }
23869
23870
23871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23872   void * jresult ;
23873   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23874   Dali::TextureSet result;
23875
23876   arg1 = (Dali::Renderer *)jarg1;
23877   {
23878     try {
23879       result = ((Dali::Renderer const *)arg1)->GetTextures();
23880     } catch (std::out_of_range& e) {
23881       {
23882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23883       };
23884     } catch (std::exception& e) {
23885       {
23886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23887       };
23888     } catch (...) {
23889       {
23890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23891       };
23892     }
23893   }
23894   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23895   return jresult;
23896 }
23897
23898
23899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
23900   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23901   Dali::Shader *arg2 = 0 ;
23902
23903   arg1 = (Dali::Renderer *)jarg1;
23904   arg2 = (Dali::Shader *)jarg2;
23905   if (!arg2) {
23906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23907     return ;
23908   }
23909   {
23910     try {
23911       (arg1)->SetShader(*arg2);
23912     } catch (std::out_of_range& e) {
23913       {
23914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23915       };
23916     } catch (std::exception& e) {
23917       {
23918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23919       };
23920     } catch (...) {
23921       {
23922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23923       };
23924     }
23925   }
23926 }
23927
23928
23929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
23930   void * jresult ;
23931   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23932   Dali::Shader result;
23933
23934   arg1 = (Dali::Renderer *)jarg1;
23935   {
23936     try {
23937       result = ((Dali::Renderer const *)arg1)->GetShader();
23938     } catch (std::out_of_range& e) {
23939       {
23940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23941       };
23942     } catch (std::exception& e) {
23943       {
23944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23945       };
23946     } catch (...) {
23947       {
23948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23949       };
23950     }
23951   }
23952   jresult = new Dali::Shader((const Dali::Shader &)result);
23953   return jresult;
23954 }
23955
23956
23957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
23958   void * jresult ;
23959   Dali::FrameBuffer::Attachment *result = 0 ;
23960
23961   {
23962     try {
23963       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
23964     } catch (std::out_of_range& e) {
23965       {
23966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23967       };
23968     } catch (std::exception& e) {
23969       {
23970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23971       };
23972     } catch (...) {
23973       {
23974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23975       };
23976     }
23977   }
23978   jresult = (void *)result;
23979   return jresult;
23980 }
23981
23982
23983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
23984   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
23985
23986   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
23987   {
23988     try {
23989       delete arg1;
23990     } catch (std::out_of_range& e) {
23991       {
23992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23993       };
23994     } catch (std::exception& e) {
23995       {
23996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23997       };
23998     } catch (...) {
23999       {
24000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24001       };
24002     }
24003   }
24004 }
24005
24006
24007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24008   void * jresult ;
24009   unsigned int arg1 ;
24010   unsigned int arg2 ;
24011   unsigned int arg3 ;
24012   Dali::FrameBuffer result;
24013
24014   arg1 = (unsigned int)jarg1;
24015   arg2 = (unsigned int)jarg2;
24016   arg3 = (unsigned int)jarg3;
24017   {
24018     try {
24019       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24020     } catch (std::out_of_range& e) {
24021       {
24022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24023       };
24024     } catch (std::exception& e) {
24025       {
24026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24027       };
24028     } catch (...) {
24029       {
24030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24031       };
24032     }
24033   }
24034   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24035   return jresult;
24036 }
24037
24038
24039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24040   void * jresult ;
24041   Dali::FrameBuffer *result = 0 ;
24042
24043   {
24044     try {
24045       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24046     } catch (std::out_of_range& e) {
24047       {
24048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24049       };
24050     } catch (std::exception& e) {
24051       {
24052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24053       };
24054     } catch (...) {
24055       {
24056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24057       };
24058     }
24059   }
24060   jresult = (void *)result;
24061   return jresult;
24062 }
24063
24064
24065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24066   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24067
24068   arg1 = (Dali::FrameBuffer *)jarg1;
24069   {
24070     try {
24071       delete arg1;
24072     } catch (std::out_of_range& e) {
24073       {
24074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24075       };
24076     } catch (std::exception& e) {
24077       {
24078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24079       };
24080     } catch (...) {
24081       {
24082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24083       };
24084     }
24085   }
24086 }
24087
24088
24089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24090   void * jresult ;
24091   Dali::FrameBuffer *arg1 = 0 ;
24092   Dali::FrameBuffer *result = 0 ;
24093
24094   arg1 = (Dali::FrameBuffer *)jarg1;
24095   if (!arg1) {
24096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24097     return 0;
24098   }
24099   {
24100     try {
24101       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24102     } catch (std::out_of_range& e) {
24103       {
24104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24105       };
24106     } catch (std::exception& e) {
24107       {
24108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24109       };
24110     } catch (...) {
24111       {
24112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24113       };
24114     }
24115   }
24116   jresult = (void *)result;
24117   return jresult;
24118 }
24119
24120
24121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24122   void * jresult ;
24123   Dali::BaseHandle arg1 ;
24124   Dali::BaseHandle *argp1 ;
24125   Dali::FrameBuffer result;
24126
24127   argp1 = (Dali::BaseHandle *)jarg1;
24128   if (!argp1) {
24129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24130     return 0;
24131   }
24132   arg1 = *argp1;
24133   {
24134     try {
24135       result = Dali::FrameBuffer::DownCast(arg1);
24136     } catch (std::out_of_range& e) {
24137       {
24138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24139       };
24140     } catch (std::exception& e) {
24141       {
24142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24143       };
24144     } catch (...) {
24145       {
24146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24147       };
24148     }
24149   }
24150   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24151   return jresult;
24152 }
24153
24154
24155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24156   void * jresult ;
24157   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24158   Dali::FrameBuffer *arg2 = 0 ;
24159   Dali::FrameBuffer *result = 0 ;
24160
24161   arg1 = (Dali::FrameBuffer *)jarg1;
24162   arg2 = (Dali::FrameBuffer *)jarg2;
24163   if (!arg2) {
24164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24165     return 0;
24166   }
24167   {
24168     try {
24169       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24170     } catch (std::out_of_range& e) {
24171       {
24172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24173       };
24174     } catch (std::exception& e) {
24175       {
24176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24177       };
24178     } catch (...) {
24179       {
24180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24181       };
24182     }
24183   }
24184   jresult = (void *)result;
24185   return jresult;
24186 }
24187
24188
24189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24190   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24191   Dali::Texture *arg2 = 0 ;
24192
24193   arg1 = (Dali::FrameBuffer *)jarg1;
24194   arg2 = (Dali::Texture *)jarg2;
24195   if (!arg2) {
24196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24197     return ;
24198   }
24199   {
24200     try {
24201       (arg1)->AttachColorTexture(*arg2);
24202     } catch (std::out_of_range& e) {
24203       {
24204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24205       };
24206     } catch (std::exception& e) {
24207       {
24208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24209       };
24210     } catch (...) {
24211       {
24212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24213       };
24214     }
24215   }
24216 }
24217
24218
24219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24220   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24221   Dali::Texture *arg2 = 0 ;
24222   unsigned int arg3 ;
24223   unsigned int arg4 ;
24224
24225   arg1 = (Dali::FrameBuffer *)jarg1;
24226   arg2 = (Dali::Texture *)jarg2;
24227   if (!arg2) {
24228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24229     return ;
24230   }
24231   arg3 = (unsigned int)jarg3;
24232   arg4 = (unsigned int)jarg4;
24233   {
24234     try {
24235       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24236     } catch (std::out_of_range& e) {
24237       {
24238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24239       };
24240     } catch (std::exception& e) {
24241       {
24242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24243       };
24244     } catch (...) {
24245       {
24246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24247       };
24248     }
24249   }
24250 }
24251
24252
24253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24254   void * jresult ;
24255   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24256   Dali::Texture result;
24257
24258   arg1 = (Dali::FrameBuffer *)jarg1;
24259   {
24260     try {
24261       result = (arg1)->GetColorTexture();
24262     } catch (std::out_of_range& e) {
24263       {
24264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24265       };
24266     } catch (std::exception& e) {
24267       {
24268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24269       };
24270     } catch (...) {
24271       {
24272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24273       };
24274     }
24275   }
24276   jresult = new Dali::Texture((const Dali::Texture &)result);
24277   return jresult;
24278 }
24279
24280
24281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24282   void * jresult ;
24283   Dali::RenderTaskList *result = 0 ;
24284
24285   {
24286     try {
24287       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24288     } catch (std::out_of_range& e) {
24289       {
24290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24291       };
24292     } catch (std::exception& e) {
24293       {
24294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24295       };
24296     } catch (...) {
24297       {
24298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24299       };
24300     }
24301   }
24302   jresult = (void *)result;
24303   return jresult;
24304 }
24305
24306
24307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24308   void * jresult ;
24309   Dali::BaseHandle arg1 ;
24310   Dali::BaseHandle *argp1 ;
24311   Dali::RenderTaskList result;
24312
24313   argp1 = (Dali::BaseHandle *)jarg1;
24314   if (!argp1) {
24315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24316     return 0;
24317   }
24318   arg1 = *argp1;
24319   {
24320     try {
24321       result = Dali::RenderTaskList::DownCast(arg1);
24322     } catch (std::out_of_range& e) {
24323       {
24324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24325       };
24326     } catch (std::exception& e) {
24327       {
24328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24329       };
24330     } catch (...) {
24331       {
24332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24333       };
24334     }
24335   }
24336   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24337   return jresult;
24338 }
24339
24340
24341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24342   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24343
24344   arg1 = (Dali::RenderTaskList *)jarg1;
24345   {
24346     try {
24347       delete arg1;
24348     } catch (std::out_of_range& e) {
24349       {
24350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24351       };
24352     } catch (std::exception& e) {
24353       {
24354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24355       };
24356     } catch (...) {
24357       {
24358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24359       };
24360     }
24361   }
24362 }
24363
24364
24365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24366   void * jresult ;
24367   Dali::RenderTaskList *arg1 = 0 ;
24368   Dali::RenderTaskList *result = 0 ;
24369
24370   arg1 = (Dali::RenderTaskList *)jarg1;
24371   if (!arg1) {
24372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24373     return 0;
24374   }
24375   {
24376     try {
24377       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24378     } catch (std::out_of_range& e) {
24379       {
24380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24381       };
24382     } catch (std::exception& e) {
24383       {
24384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24385       };
24386     } catch (...) {
24387       {
24388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24389       };
24390     }
24391   }
24392   jresult = (void *)result;
24393   return jresult;
24394 }
24395
24396
24397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24398   void * jresult ;
24399   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24400   Dali::RenderTaskList *arg2 = 0 ;
24401   Dali::RenderTaskList *result = 0 ;
24402
24403   arg1 = (Dali::RenderTaskList *)jarg1;
24404   arg2 = (Dali::RenderTaskList *)jarg2;
24405   if (!arg2) {
24406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24407     return 0;
24408   }
24409   {
24410     try {
24411       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24412     } catch (std::out_of_range& e) {
24413       {
24414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24415       };
24416     } catch (std::exception& e) {
24417       {
24418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24419       };
24420     } catch (...) {
24421       {
24422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24423       };
24424     }
24425   }
24426   jresult = (void *)result;
24427   return jresult;
24428 }
24429
24430
24431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24432   void * jresult ;
24433   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24434   Dali::RenderTask result;
24435
24436   arg1 = (Dali::RenderTaskList *)jarg1;
24437   {
24438     try {
24439       result = (arg1)->CreateTask();
24440     } catch (std::out_of_range& e) {
24441       {
24442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24443       };
24444     } catch (std::exception& e) {
24445       {
24446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24447       };
24448     } catch (...) {
24449       {
24450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24451       };
24452     }
24453   }
24454   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24455   return jresult;
24456 }
24457
24458
24459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24460   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24461   Dali::RenderTask arg2 ;
24462   Dali::RenderTask *argp2 ;
24463
24464   arg1 = (Dali::RenderTaskList *)jarg1;
24465   argp2 = (Dali::RenderTask *)jarg2;
24466   if (!argp2) {
24467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24468     return ;
24469   }
24470   arg2 = *argp2;
24471   {
24472     try {
24473       (arg1)->RemoveTask(arg2);
24474     } catch (std::out_of_range& e) {
24475       {
24476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24477       };
24478     } catch (std::exception& e) {
24479       {
24480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24481       };
24482     } catch (...) {
24483       {
24484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24485       };
24486     }
24487   }
24488 }
24489
24490
24491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24492   unsigned int jresult ;
24493   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24494   unsigned int result;
24495
24496   arg1 = (Dali::RenderTaskList *)jarg1;
24497   {
24498     try {
24499       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24500     } catch (std::out_of_range& e) {
24501       {
24502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24503       };
24504     } catch (std::exception& e) {
24505       {
24506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24507       };
24508     } catch (...) {
24509       {
24510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24511       };
24512     }
24513   }
24514   jresult = result;
24515   return jresult;
24516 }
24517
24518
24519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24520   void * jresult ;
24521   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24522   unsigned int arg2 ;
24523   Dali::RenderTask result;
24524
24525   arg1 = (Dali::RenderTaskList *)jarg1;
24526   arg2 = (unsigned int)jarg2;
24527   {
24528     try {
24529       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24530     } catch (std::out_of_range& e) {
24531       {
24532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24533       };
24534     } catch (std::exception& e) {
24535       {
24536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24537       };
24538     } catch (...) {
24539       {
24540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24541       };
24542     }
24543   }
24544   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24545   return jresult;
24546 }
24547
24548
24549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24550   int jresult ;
24551   int result;
24552
24553   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24554   jresult = (int)result;
24555   return jresult;
24556 }
24557
24558
24559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24560   int jresult ;
24561   int result;
24562
24563   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24564   jresult = (int)result;
24565   return jresult;
24566 }
24567
24568
24569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24570   int jresult ;
24571   int result;
24572
24573   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24574   jresult = (int)result;
24575   return jresult;
24576 }
24577
24578
24579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24580   int jresult ;
24581   int result;
24582
24583   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24584   jresult = (int)result;
24585   return jresult;
24586 }
24587
24588
24589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24590   void * jresult ;
24591   Dali::RenderTask::Property *result = 0 ;
24592
24593   {
24594     try {
24595       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24596     } catch (std::out_of_range& e) {
24597       {
24598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24599       };
24600     } catch (std::exception& e) {
24601       {
24602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24603       };
24604     } catch (...) {
24605       {
24606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24607       };
24608     }
24609   }
24610   jresult = (void *)result;
24611   return jresult;
24612 }
24613
24614
24615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24616   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24617
24618   arg1 = (Dali::RenderTask::Property *)jarg1;
24619   {
24620     try {
24621       delete arg1;
24622     } catch (std::out_of_range& e) {
24623       {
24624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24625       };
24626     } catch (std::exception& e) {
24627       {
24628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24629       };
24630     } catch (...) {
24631       {
24632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24633       };
24634     }
24635   }
24636 }
24637
24638
24639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24640   void * jresult ;
24641   bool (*result)(Dali::Vector2 &) = 0 ;
24642
24643   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24644   jresult = (void *)result;
24645   return jresult;
24646 }
24647
24648
24649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24650   void * jresult ;
24651   bool (*result)(Dali::Vector2 &) = 0 ;
24652
24653   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24654   jresult = (void *)result;
24655   return jresult;
24656 }
24657
24658
24659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24660   unsigned int jresult ;
24661   bool result;
24662
24663   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24664   jresult = result;
24665   return jresult;
24666 }
24667
24668
24669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24670   unsigned int jresult ;
24671   bool result;
24672
24673   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24674   jresult = result;
24675   return jresult;
24676 }
24677
24678
24679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24680   void * jresult ;
24681   Dali::Vector4 *result = 0 ;
24682
24683   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24684   jresult = (void *)result;
24685   return jresult;
24686 }
24687
24688
24689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24690   unsigned int jresult ;
24691   bool result;
24692
24693   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24694   jresult = result;
24695   return jresult;
24696 }
24697
24698
24699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24700   unsigned int jresult ;
24701   bool result;
24702
24703   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24704   jresult = result;
24705   return jresult;
24706 }
24707
24708
24709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24710   unsigned int jresult ;
24711   unsigned int result;
24712
24713   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24714   jresult = result;
24715   return jresult;
24716 }
24717
24718
24719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24720   void * jresult ;
24721   Dali::RenderTask *result = 0 ;
24722
24723   {
24724     try {
24725       result = (Dali::RenderTask *)new Dali::RenderTask();
24726     } catch (std::out_of_range& e) {
24727       {
24728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24729       };
24730     } catch (std::exception& e) {
24731       {
24732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24733       };
24734     } catch (...) {
24735       {
24736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24737       };
24738     }
24739   }
24740   jresult = (void *)result;
24741   return jresult;
24742 }
24743
24744
24745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24746   void * jresult ;
24747   Dali::BaseHandle arg1 ;
24748   Dali::BaseHandle *argp1 ;
24749   Dali::RenderTask result;
24750
24751   argp1 = (Dali::BaseHandle *)jarg1;
24752   if (!argp1) {
24753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24754     return 0;
24755   }
24756   arg1 = *argp1;
24757   {
24758     try {
24759       result = Dali::RenderTask::DownCast(arg1);
24760     } catch (std::out_of_range& e) {
24761       {
24762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24763       };
24764     } catch (std::exception& e) {
24765       {
24766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24767       };
24768     } catch (...) {
24769       {
24770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24771       };
24772     }
24773   }
24774   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24775   return jresult;
24776 }
24777
24778
24779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24780   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24781
24782   arg1 = (Dali::RenderTask *)jarg1;
24783   {
24784     try {
24785       delete arg1;
24786     } catch (std::out_of_range& e) {
24787       {
24788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24789       };
24790     } catch (std::exception& e) {
24791       {
24792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24793       };
24794     } catch (...) {
24795       {
24796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24797       };
24798     }
24799   }
24800 }
24801
24802
24803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24804   void * jresult ;
24805   Dali::RenderTask *arg1 = 0 ;
24806   Dali::RenderTask *result = 0 ;
24807
24808   arg1 = (Dali::RenderTask *)jarg1;
24809   if (!arg1) {
24810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24811     return 0;
24812   }
24813   {
24814     try {
24815       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24816     } catch (std::out_of_range& e) {
24817       {
24818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24819       };
24820     } catch (std::exception& e) {
24821       {
24822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24823       };
24824     } catch (...) {
24825       {
24826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24827       };
24828     }
24829   }
24830   jresult = (void *)result;
24831   return jresult;
24832 }
24833
24834
24835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24836   void * jresult ;
24837   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24838   Dali::RenderTask *arg2 = 0 ;
24839   Dali::RenderTask *result = 0 ;
24840
24841   arg1 = (Dali::RenderTask *)jarg1;
24842   arg2 = (Dali::RenderTask *)jarg2;
24843   if (!arg2) {
24844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24845     return 0;
24846   }
24847   {
24848     try {
24849       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24850     } catch (std::out_of_range& e) {
24851       {
24852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24853       };
24854     } catch (std::exception& e) {
24855       {
24856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24857       };
24858     } catch (...) {
24859       {
24860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24861       };
24862     }
24863   }
24864   jresult = (void *)result;
24865   return jresult;
24866 }
24867
24868
24869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24870   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24871   Dali::Actor arg2 ;
24872   Dali::Actor *argp2 ;
24873
24874   arg1 = (Dali::RenderTask *)jarg1;
24875   argp2 = (Dali::Actor *)jarg2;
24876   if (!argp2) {
24877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24878     return ;
24879   }
24880   arg2 = *argp2;
24881   {
24882     try {
24883       (arg1)->SetSourceActor(arg2);
24884     } catch (std::out_of_range& e) {
24885       {
24886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24887       };
24888     } catch (std::exception& e) {
24889       {
24890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24891       };
24892     } catch (...) {
24893       {
24894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24895       };
24896     }
24897   }
24898 }
24899
24900
24901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
24902   void * jresult ;
24903   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24904   Dali::Actor result;
24905
24906   arg1 = (Dali::RenderTask *)jarg1;
24907   {
24908     try {
24909       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
24910     } catch (std::out_of_range& e) {
24911       {
24912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24913       };
24914     } catch (std::exception& e) {
24915       {
24916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24917       };
24918     } catch (...) {
24919       {
24920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24921       };
24922     }
24923   }
24924   jresult = new Dali::Actor((const Dali::Actor &)result);
24925   return jresult;
24926 }
24927
24928
24929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
24930   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24931   bool arg2 ;
24932
24933   arg1 = (Dali::RenderTask *)jarg1;
24934   arg2 = jarg2 ? true : false;
24935   {
24936     try {
24937       (arg1)->SetExclusive(arg2);
24938     } catch (std::out_of_range& e) {
24939       {
24940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24941       };
24942     } catch (std::exception& e) {
24943       {
24944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24945       };
24946     } catch (...) {
24947       {
24948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24949       };
24950     }
24951   }
24952 }
24953
24954
24955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
24956   unsigned int jresult ;
24957   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24958   bool result;
24959
24960   arg1 = (Dali::RenderTask *)jarg1;
24961   {
24962     try {
24963       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
24964     } catch (std::out_of_range& e) {
24965       {
24966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24967       };
24968     } catch (std::exception& e) {
24969       {
24970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24971       };
24972     } catch (...) {
24973       {
24974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24975       };
24976     }
24977   }
24978   jresult = result;
24979   return jresult;
24980 }
24981
24982
24983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
24984   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24985   bool arg2 ;
24986
24987   arg1 = (Dali::RenderTask *)jarg1;
24988   arg2 = jarg2 ? true : false;
24989   {
24990     try {
24991       (arg1)->SetInputEnabled(arg2);
24992     } catch (std::out_of_range& e) {
24993       {
24994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24995       };
24996     } catch (std::exception& e) {
24997       {
24998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24999       };
25000     } catch (...) {
25001       {
25002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25003       };
25004     }
25005   }
25006 }
25007
25008
25009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25010   unsigned int jresult ;
25011   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25012   bool result;
25013
25014   arg1 = (Dali::RenderTask *)jarg1;
25015   {
25016     try {
25017       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25018     } catch (std::out_of_range& e) {
25019       {
25020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25021       };
25022     } catch (std::exception& e) {
25023       {
25024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25025       };
25026     } catch (...) {
25027       {
25028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25029       };
25030     }
25031   }
25032   jresult = result;
25033   return jresult;
25034 }
25035
25036
25037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25038   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25039   Dali::CameraActor arg2 ;
25040   Dali::CameraActor *argp2 ;
25041
25042   arg1 = (Dali::RenderTask *)jarg1;
25043   argp2 = (Dali::CameraActor *)jarg2;
25044   if (!argp2) {
25045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25046     return ;
25047   }
25048   arg2 = *argp2;
25049   {
25050     try {
25051       (arg1)->SetCameraActor(arg2);
25052     } catch (std::out_of_range& e) {
25053       {
25054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25055       };
25056     } catch (std::exception& e) {
25057       {
25058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25059       };
25060     } catch (...) {
25061       {
25062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25063       };
25064     }
25065   }
25066 }
25067
25068
25069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25070   void * jresult ;
25071   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25072   Dali::CameraActor result;
25073
25074   arg1 = (Dali::RenderTask *)jarg1;
25075   {
25076     try {
25077       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25078     } catch (std::out_of_range& e) {
25079       {
25080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25081       };
25082     } catch (std::exception& e) {
25083       {
25084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25085       };
25086     } catch (...) {
25087       {
25088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25089       };
25090     }
25091   }
25092   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25093   return jresult;
25094 }
25095
25096
25097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25098   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25099   Dali::FrameBufferImage arg2 ;
25100   Dali::FrameBufferImage *argp2 ;
25101
25102   arg1 = (Dali::RenderTask *)jarg1;
25103   argp2 = (Dali::FrameBufferImage *)jarg2;
25104   if (!argp2) {
25105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25106     return ;
25107   }
25108   arg2 = *argp2;
25109   {
25110     try {
25111       (arg1)->SetTargetFrameBuffer(arg2);
25112     } catch (std::out_of_range& e) {
25113       {
25114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25115       };
25116     } catch (std::exception& e) {
25117       {
25118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25119       };
25120     } catch (...) {
25121       {
25122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25123       };
25124     }
25125   }
25126 }
25127
25128
25129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25130   void * jresult ;
25131   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25132   Dali::FrameBufferImage result;
25133
25134   arg1 = (Dali::RenderTask *)jarg1;
25135   {
25136     try {
25137       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25138     } catch (std::out_of_range& e) {
25139       {
25140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25141       };
25142     } catch (std::exception& e) {
25143       {
25144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25145       };
25146     } catch (...) {
25147       {
25148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25149       };
25150     }
25151   }
25152   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25153   return jresult;
25154 }
25155
25156
25157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25158   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25159   Dali::FrameBuffer arg2 ;
25160   Dali::FrameBuffer *argp2 ;
25161
25162   arg1 = (Dali::RenderTask *)jarg1;
25163   argp2 = (Dali::FrameBuffer *)jarg2;
25164   if (!argp2) {
25165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25166     return ;
25167   }
25168   arg2 = *argp2;
25169   {
25170     try {
25171       (arg1)->SetFrameBuffer(arg2);
25172     } catch (std::out_of_range& e) {
25173       {
25174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25175       };
25176     } catch (std::exception& e) {
25177       {
25178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25179       };
25180     } catch (...) {
25181       {
25182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25183       };
25184     }
25185   }
25186 }
25187
25188
25189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25190   void * jresult ;
25191   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25192   Dali::FrameBuffer result;
25193
25194   arg1 = (Dali::RenderTask *)jarg1;
25195   {
25196     try {
25197       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25198     } catch (std::out_of_range& e) {
25199       {
25200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25201       };
25202     } catch (std::exception& e) {
25203       {
25204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25205       };
25206     } catch (...) {
25207       {
25208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25209       };
25210     }
25211   }
25212   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25213   return jresult;
25214 }
25215
25216
25217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25218   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25219   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25220
25221   arg1 = (Dali::RenderTask *)jarg1;
25222   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25223   {
25224     try {
25225       (arg1)->SetScreenToFrameBufferFunction(arg2);
25226     } catch (std::out_of_range& e) {
25227       {
25228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25229       };
25230     } catch (std::exception& e) {
25231       {
25232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25233       };
25234     } catch (...) {
25235       {
25236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25237       };
25238     }
25239   }
25240 }
25241
25242
25243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25244   void * jresult ;
25245   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25246   Dali::RenderTask::ScreenToFrameBufferFunction result;
25247
25248   arg1 = (Dali::RenderTask *)jarg1;
25249   {
25250     try {
25251       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25252     } catch (std::out_of_range& e) {
25253       {
25254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25255       };
25256     } catch (std::exception& e) {
25257       {
25258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25259       };
25260     } catch (...) {
25261       {
25262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25263       };
25264     }
25265   }
25266   jresult = (void *)result;
25267   return jresult;
25268 }
25269
25270
25271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25272   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25273   Dali::Actor arg2 ;
25274   Dali::Actor *argp2 ;
25275
25276   arg1 = (Dali::RenderTask *)jarg1;
25277   argp2 = (Dali::Actor *)jarg2;
25278   if (!argp2) {
25279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25280     return ;
25281   }
25282   arg2 = *argp2;
25283   {
25284     try {
25285       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25286     } catch (std::out_of_range& e) {
25287       {
25288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25289       };
25290     } catch (std::exception& e) {
25291       {
25292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25293       };
25294     } catch (...) {
25295       {
25296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25297       };
25298     }
25299   }
25300 }
25301
25302
25303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25304   void * jresult ;
25305   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25306   Dali::Actor result;
25307
25308   arg1 = (Dali::RenderTask *)jarg1;
25309   {
25310     try {
25311       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25312     } catch (std::out_of_range& e) {
25313       {
25314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25315       };
25316     } catch (std::exception& e) {
25317       {
25318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25319       };
25320     } catch (...) {
25321       {
25322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25323       };
25324     }
25325   }
25326   jresult = new Dali::Actor((const Dali::Actor &)result);
25327   return jresult;
25328 }
25329
25330
25331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25332   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25333   Dali::Vector2 arg2 ;
25334   Dali::Vector2 *argp2 ;
25335
25336   arg1 = (Dali::RenderTask *)jarg1;
25337   argp2 = (Dali::Vector2 *)jarg2;
25338   if (!argp2) {
25339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25340     return ;
25341   }
25342   arg2 = *argp2;
25343   {
25344     try {
25345       (arg1)->SetViewportPosition(arg2);
25346     } catch (std::out_of_range& e) {
25347       {
25348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25349       };
25350     } catch (std::exception& e) {
25351       {
25352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25353       };
25354     } catch (...) {
25355       {
25356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25357       };
25358     }
25359   }
25360 }
25361
25362
25363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25364   void * jresult ;
25365   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25366   Dali::Vector2 result;
25367
25368   arg1 = (Dali::RenderTask *)jarg1;
25369   {
25370     try {
25371       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25372     } catch (std::out_of_range& e) {
25373       {
25374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25375       };
25376     } catch (std::exception& e) {
25377       {
25378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25379       };
25380     } catch (...) {
25381       {
25382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25383       };
25384     }
25385   }
25386   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25387   return jresult;
25388 }
25389
25390
25391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25392   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25393   Dali::Vector2 arg2 ;
25394   Dali::Vector2 *argp2 ;
25395
25396   arg1 = (Dali::RenderTask *)jarg1;
25397   argp2 = (Dali::Vector2 *)jarg2;
25398   if (!argp2) {
25399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25400     return ;
25401   }
25402   arg2 = *argp2;
25403   {
25404     try {
25405       (arg1)->SetViewportSize(arg2);
25406     } catch (std::out_of_range& e) {
25407       {
25408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25409       };
25410     } catch (std::exception& e) {
25411       {
25412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25413       };
25414     } catch (...) {
25415       {
25416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25417       };
25418     }
25419   }
25420 }
25421
25422
25423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25424   void * jresult ;
25425   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25426   Dali::Vector2 result;
25427
25428   arg1 = (Dali::RenderTask *)jarg1;
25429   {
25430     try {
25431       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25432     } catch (std::out_of_range& e) {
25433       {
25434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25435       };
25436     } catch (std::exception& e) {
25437       {
25438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25439       };
25440     } catch (...) {
25441       {
25442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25443       };
25444     }
25445   }
25446   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25447   return jresult;
25448 }
25449
25450
25451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25452   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25453   Dali::Viewport arg2 ;
25454   Dali::Viewport *argp2 ;
25455
25456   arg1 = (Dali::RenderTask *)jarg1;
25457   argp2 = (Dali::Viewport *)jarg2;
25458   if (!argp2) {
25459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25460     return ;
25461   }
25462   arg2 = *argp2;
25463   {
25464     try {
25465       (arg1)->SetViewport(arg2);
25466     } catch (std::out_of_range& e) {
25467       {
25468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25469       };
25470     } catch (std::exception& e) {
25471       {
25472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25473       };
25474     } catch (...) {
25475       {
25476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25477       };
25478     }
25479   }
25480 }
25481
25482
25483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25484   void * jresult ;
25485   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25486   Dali::Viewport result;
25487
25488   arg1 = (Dali::RenderTask *)jarg1;
25489   {
25490     try {
25491       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25492     } catch (std::out_of_range& e) {
25493       {
25494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25495       };
25496     } catch (std::exception& e) {
25497       {
25498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25499       };
25500     } catch (...) {
25501       {
25502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25503       };
25504     }
25505   }
25506   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25507   return jresult;
25508 }
25509
25510
25511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25512   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25513   Dali::Vector4 *arg2 = 0 ;
25514
25515   arg1 = (Dali::RenderTask *)jarg1;
25516   arg2 = (Dali::Vector4 *)jarg2;
25517   if (!arg2) {
25518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25519     return ;
25520   }
25521   {
25522     try {
25523       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25524     } catch (std::out_of_range& e) {
25525       {
25526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25527       };
25528     } catch (std::exception& e) {
25529       {
25530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25531       };
25532     } catch (...) {
25533       {
25534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25535       };
25536     }
25537   }
25538 }
25539
25540
25541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25542   void * jresult ;
25543   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25544   Dali::Vector4 result;
25545
25546   arg1 = (Dali::RenderTask *)jarg1;
25547   {
25548     try {
25549       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25550     } catch (std::out_of_range& e) {
25551       {
25552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25553       };
25554     } catch (std::exception& e) {
25555       {
25556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25557       };
25558     } catch (...) {
25559       {
25560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25561       };
25562     }
25563   }
25564   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25565   return jresult;
25566 }
25567
25568
25569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25570   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25571   bool arg2 ;
25572
25573   arg1 = (Dali::RenderTask *)jarg1;
25574   arg2 = jarg2 ? true : false;
25575   {
25576     try {
25577       (arg1)->SetClearEnabled(arg2);
25578     } catch (std::out_of_range& e) {
25579       {
25580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25581       };
25582     } catch (std::exception& e) {
25583       {
25584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25585       };
25586     } catch (...) {
25587       {
25588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25589       };
25590     }
25591   }
25592 }
25593
25594
25595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25596   unsigned int jresult ;
25597   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25598   bool result;
25599
25600   arg1 = (Dali::RenderTask *)jarg1;
25601   {
25602     try {
25603       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25604     } catch (std::out_of_range& e) {
25605       {
25606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25607       };
25608     } catch (std::exception& e) {
25609       {
25610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25611       };
25612     } catch (...) {
25613       {
25614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25615       };
25616     }
25617   }
25618   jresult = result;
25619   return jresult;
25620 }
25621
25622
25623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25624   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25625   bool arg2 ;
25626
25627   arg1 = (Dali::RenderTask *)jarg1;
25628   arg2 = jarg2 ? true : false;
25629   {
25630     try {
25631       (arg1)->SetCullMode(arg2);
25632     } catch (std::out_of_range& e) {
25633       {
25634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25635       };
25636     } catch (std::exception& e) {
25637       {
25638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25639       };
25640     } catch (...) {
25641       {
25642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25643       };
25644     }
25645   }
25646 }
25647
25648
25649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25650   unsigned int jresult ;
25651   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25652   bool result;
25653
25654   arg1 = (Dali::RenderTask *)jarg1;
25655   {
25656     try {
25657       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25658     } catch (std::out_of_range& e) {
25659       {
25660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25661       };
25662     } catch (std::exception& e) {
25663       {
25664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25665       };
25666     } catch (...) {
25667       {
25668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25669       };
25670     }
25671   }
25672   jresult = result;
25673   return jresult;
25674 }
25675
25676
25677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25678   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25679   unsigned int arg2 ;
25680
25681   arg1 = (Dali::RenderTask *)jarg1;
25682   arg2 = (unsigned int)jarg2;
25683   {
25684     try {
25685       (arg1)->SetRefreshRate(arg2);
25686     } catch (std::out_of_range& e) {
25687       {
25688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25689       };
25690     } catch (std::exception& e) {
25691       {
25692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25693       };
25694     } catch (...) {
25695       {
25696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25697       };
25698     }
25699   }
25700 }
25701
25702
25703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25704   unsigned int jresult ;
25705   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25706   unsigned int result;
25707
25708   arg1 = (Dali::RenderTask *)jarg1;
25709   {
25710     try {
25711       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25712     } catch (std::out_of_range& e) {
25713       {
25714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25715       };
25716     } catch (std::exception& e) {
25717       {
25718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25719       };
25720     } catch (...) {
25721       {
25722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25723       };
25724     }
25725   }
25726   jresult = result;
25727   return jresult;
25728 }
25729
25730
25731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25732   unsigned int jresult ;
25733   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25734   Dali::Vector3 *arg2 = 0 ;
25735   float *arg3 = 0 ;
25736   float *arg4 = 0 ;
25737   bool result;
25738
25739   arg1 = (Dali::RenderTask *)jarg1;
25740   arg2 = (Dali::Vector3 *)jarg2;
25741   if (!arg2) {
25742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25743     return 0;
25744   }
25745   arg3 = (float *)jarg3;
25746   arg4 = (float *)jarg4;
25747   {
25748     try {
25749       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25750     } catch (std::out_of_range& e) {
25751       {
25752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25753       };
25754     } catch (std::exception& e) {
25755       {
25756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25757       };
25758     } catch (...) {
25759       {
25760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25761       };
25762     }
25763   }
25764   jresult = result;
25765   return jresult;
25766 }
25767
25768
25769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25770   unsigned int jresult ;
25771   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25772   Dali::Actor arg2 ;
25773   float arg3 ;
25774   float arg4 ;
25775   float *arg5 = 0 ;
25776   float *arg6 = 0 ;
25777   Dali::Actor *argp2 ;
25778   bool result;
25779
25780   arg1 = (Dali::RenderTask *)jarg1;
25781   argp2 = (Dali::Actor *)jarg2;
25782   if (!argp2) {
25783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25784     return 0;
25785   }
25786   arg2 = *argp2;
25787   arg3 = (float)jarg3;
25788   arg4 = (float)jarg4;
25789   arg5 = (float *)jarg5;
25790   arg6 = (float *)jarg6;
25791   {
25792     try {
25793       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25794     } catch (std::out_of_range& e) {
25795       {
25796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25797       };
25798     } catch (std::exception& e) {
25799       {
25800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25801       };
25802     } catch (...) {
25803       {
25804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25805       };
25806     }
25807   }
25808   jresult = result;
25809   return jresult;
25810 }
25811
25812
25813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25814   void * jresult ;
25815   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25816   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25817
25818   arg1 = (Dali::RenderTask *)jarg1;
25819   {
25820     try {
25821       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25822     } catch (std::out_of_range& e) {
25823       {
25824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25825       };
25826     } catch (std::exception& e) {
25827       {
25828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25829       };
25830     } catch (...) {
25831       {
25832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25833       };
25834     }
25835   }
25836   jresult = (void *)result;
25837   return jresult;
25838 }
25839
25840
25841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25842   void * jresult ;
25843   int arg1 ;
25844   Dali::TouchPoint::State arg2 ;
25845   float arg3 ;
25846   float arg4 ;
25847   Dali::TouchPoint *result = 0 ;
25848
25849   arg1 = (int)jarg1;
25850   arg2 = (Dali::TouchPoint::State)jarg2;
25851   arg3 = (float)jarg3;
25852   arg4 = (float)jarg4;
25853   {
25854     try {
25855       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25856     } catch (std::out_of_range& e) {
25857       {
25858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25859       };
25860     } catch (std::exception& e) {
25861       {
25862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25863       };
25864     } catch (...) {
25865       {
25866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25867       };
25868     }
25869   }
25870   jresult = (void *)result;
25871   return jresult;
25872 }
25873
25874
25875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25876   void * jresult ;
25877   int arg1 ;
25878   Dali::TouchPoint::State arg2 ;
25879   float arg3 ;
25880   float arg4 ;
25881   float arg5 ;
25882   float arg6 ;
25883   Dali::TouchPoint *result = 0 ;
25884
25885   arg1 = (int)jarg1;
25886   arg2 = (Dali::TouchPoint::State)jarg2;
25887   arg3 = (float)jarg3;
25888   arg4 = (float)jarg4;
25889   arg5 = (float)jarg5;
25890   arg6 = (float)jarg6;
25891   {
25892     try {
25893       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25894     } catch (std::out_of_range& e) {
25895       {
25896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25897       };
25898     } catch (std::exception& e) {
25899       {
25900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25901       };
25902     } catch (...) {
25903       {
25904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25905       };
25906     }
25907   }
25908   jresult = (void *)result;
25909   return jresult;
25910 }
25911
25912
25913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
25914   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25915
25916   arg1 = (Dali::TouchPoint *)jarg1;
25917   {
25918     try {
25919       delete arg1;
25920     } catch (std::out_of_range& e) {
25921       {
25922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25923       };
25924     } catch (std::exception& e) {
25925       {
25926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25927       };
25928     } catch (...) {
25929       {
25930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25931       };
25932     }
25933   }
25934 }
25935
25936
25937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
25938   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25939   int arg2 ;
25940
25941   arg1 = (Dali::TouchPoint *)jarg1;
25942   arg2 = (int)jarg2;
25943   if (arg1) (arg1)->deviceId = arg2;
25944 }
25945
25946
25947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
25948   int jresult ;
25949   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25950   int result;
25951
25952   arg1 = (Dali::TouchPoint *)jarg1;
25953   result = (int) ((arg1)->deviceId);
25954   jresult = result;
25955   return jresult;
25956 }
25957
25958
25959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
25960   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25961   Dali::TouchPoint::State arg2 ;
25962
25963   arg1 = (Dali::TouchPoint *)jarg1;
25964   arg2 = (Dali::TouchPoint::State)jarg2;
25965   if (arg1) (arg1)->state = arg2;
25966 }
25967
25968
25969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
25970   int jresult ;
25971   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25972   Dali::TouchPoint::State result;
25973
25974   arg1 = (Dali::TouchPoint *)jarg1;
25975   result = (Dali::TouchPoint::State) ((arg1)->state);
25976   jresult = (int)result;
25977   return jresult;
25978 }
25979
25980
25981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
25982   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25983   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
25984
25985   arg1 = (Dali::TouchPoint *)jarg1;
25986   arg2 = (Dali::Actor *)jarg2;
25987   if (arg1) (arg1)->hitActor = *arg2;
25988 }
25989
25990
25991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
25992   void * jresult ;
25993   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25994   Dali::Actor *result = 0 ;
25995
25996   arg1 = (Dali::TouchPoint *)jarg1;
25997   result = (Dali::Actor *)& ((arg1)->hitActor);
25998   jresult = (void *)result;
25999   return jresult;
26000 }
26001
26002
26003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26004   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26005   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26006
26007   arg1 = (Dali::TouchPoint *)jarg1;
26008   arg2 = (Dali::Vector2 *)jarg2;
26009   if (arg1) (arg1)->local = *arg2;
26010 }
26011
26012
26013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26014   void * jresult ;
26015   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26016   Dali::Vector2 *result = 0 ;
26017
26018   arg1 = (Dali::TouchPoint *)jarg1;
26019   result = (Dali::Vector2 *)& ((arg1)->local);
26020   jresult = (void *)result;
26021   return jresult;
26022 }
26023
26024
26025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26026   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26027   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26028
26029   arg1 = (Dali::TouchPoint *)jarg1;
26030   arg2 = (Dali::Vector2 *)jarg2;
26031   if (arg1) (arg1)->screen = *arg2;
26032 }
26033
26034
26035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26036   void * jresult ;
26037   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26038   Dali::Vector2 *result = 0 ;
26039
26040   arg1 = (Dali::TouchPoint *)jarg1;
26041   result = (Dali::Vector2 *)& ((arg1)->screen);
26042   jresult = (void *)result;
26043   return jresult;
26044 }
26045
26046
26047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26048   void * jresult ;
26049   Dali::TouchData *result = 0 ;
26050
26051   {
26052     try {
26053       result = (Dali::TouchData *)new Dali::TouchData();
26054     } catch (std::out_of_range& e) {
26055       {
26056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26057       };
26058     } catch (std::exception& e) {
26059       {
26060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26061       };
26062     } catch (...) {
26063       {
26064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26065       };
26066     }
26067   }
26068   jresult = (void *)result;
26069   return jresult;
26070 }
26071
26072
26073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26074   void * jresult ;
26075   Dali::TouchData *arg1 = 0 ;
26076   Dali::TouchData *result = 0 ;
26077
26078   arg1 = (Dali::TouchData *)jarg1;
26079   if (!arg1) {
26080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26081     return 0;
26082   }
26083   {
26084     try {
26085       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26086     } catch (std::out_of_range& e) {
26087       {
26088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26089       };
26090     } catch (std::exception& e) {
26091       {
26092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26093       };
26094     } catch (...) {
26095       {
26096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26097       };
26098     }
26099   }
26100   jresult = (void *)result;
26101   return jresult;
26102 }
26103
26104
26105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26106   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26107
26108   arg1 = (Dali::TouchData *)jarg1;
26109   {
26110     try {
26111       delete arg1;
26112     } catch (std::out_of_range& e) {
26113       {
26114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26115       };
26116     } catch (std::exception& e) {
26117       {
26118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26119       };
26120     } catch (...) {
26121       {
26122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26123       };
26124     }
26125   }
26126 }
26127
26128
26129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26130   void * jresult ;
26131   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26132   Dali::TouchData *arg2 = 0 ;
26133   Dali::TouchData *result = 0 ;
26134
26135   arg1 = (Dali::TouchData *)jarg1;
26136   arg2 = (Dali::TouchData *)jarg2;
26137   if (!arg2) {
26138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26139     return 0;
26140   }
26141   {
26142     try {
26143       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26144     } catch (std::out_of_range& e) {
26145       {
26146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26147       };
26148     } catch (std::exception& e) {
26149       {
26150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26151       };
26152     } catch (...) {
26153       {
26154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26155       };
26156     }
26157   }
26158   jresult = (void *)result;
26159   return jresult;
26160 }
26161
26162
26163 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26164   unsigned long jresult ;
26165   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26166   unsigned long result;
26167
26168   arg1 = (Dali::TouchData *)jarg1;
26169   {
26170     try {
26171       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26172     } catch (std::out_of_range& e) {
26173       {
26174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26175       };
26176     } catch (std::exception& e) {
26177       {
26178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26179       };
26180     } catch (...) {
26181       {
26182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26183       };
26184     }
26185   }
26186   jresult = (unsigned long)result;
26187   return jresult;
26188 }
26189
26190
26191 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26192   unsigned long jresult ;
26193   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26194   std::size_t result;
26195
26196   arg1 = (Dali::TouchData *)jarg1;
26197   {
26198     try {
26199       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26200     } catch (std::out_of_range& e) {
26201       {
26202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26203       };
26204     } catch (std::exception& e) {
26205       {
26206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26207       };
26208     } catch (...) {
26209       {
26210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26211       };
26212     }
26213   }
26214   jresult = (unsigned long)result;
26215   return jresult;
26216 }
26217
26218
26219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26220   int jresult ;
26221   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26222   std::size_t arg2 ;
26223   int32_t result;
26224
26225   arg1 = (Dali::TouchData *)jarg1;
26226   arg2 = (std::size_t)jarg2;
26227   {
26228     try {
26229       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26230     } catch (std::out_of_range& e) {
26231       {
26232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26233       };
26234     } catch (std::exception& e) {
26235       {
26236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26237       };
26238     } catch (...) {
26239       {
26240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26241       };
26242     }
26243   }
26244   jresult = result;
26245   return jresult;
26246 }
26247
26248
26249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26250   int jresult ;
26251   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26252   std::size_t arg2 ;
26253   Dali::PointState::Type result;
26254
26255   arg1 = (Dali::TouchData *)jarg1;
26256   arg2 = (std::size_t)jarg2;
26257   {
26258     try {
26259       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26260     } catch (std::out_of_range& e) {
26261       {
26262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26263       };
26264     } catch (std::exception& e) {
26265       {
26266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26267       };
26268     } catch (...) {
26269       {
26270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26271       };
26272     }
26273   }
26274   jresult = (int)result;
26275   return jresult;
26276 }
26277
26278
26279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26280   void * jresult ;
26281   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26282   std::size_t arg2 ;
26283   Dali::Actor result;
26284
26285   arg1 = (Dali::TouchData *)jarg1;
26286   arg2 = (std::size_t)jarg2;
26287   {
26288     try {
26289       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26290     } catch (std::out_of_range& e) {
26291       {
26292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26293       };
26294     } catch (std::exception& e) {
26295       {
26296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26297       };
26298     } catch (...) {
26299       {
26300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26301       };
26302     }
26303   }
26304   jresult = new Dali::Actor((const Dali::Actor &)result);
26305   return jresult;
26306 }
26307
26308
26309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26310   void * jresult ;
26311   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26312   std::size_t arg2 ;
26313   Dali::Vector2 *result = 0 ;
26314
26315   arg1 = (Dali::TouchData *)jarg1;
26316   arg2 = (std::size_t)jarg2;
26317   {
26318     try {
26319       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26320     } catch (std::out_of_range& e) {
26321       {
26322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26323       };
26324     } catch (std::exception& e) {
26325       {
26326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26327       };
26328     } catch (...) {
26329       {
26330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26331       };
26332     }
26333   }
26334   jresult = (void *)result;
26335   return jresult;
26336 }
26337
26338
26339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26340   void * jresult ;
26341   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26342   std::size_t arg2 ;
26343   Dali::Vector2 *result = 0 ;
26344
26345   arg1 = (Dali::TouchData *)jarg1;
26346   arg2 = (std::size_t)jarg2;
26347   {
26348     try {
26349       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26350     } catch (std::out_of_range& e) {
26351       {
26352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26353       };
26354     } catch (std::exception& e) {
26355       {
26356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26357       };
26358     } catch (...) {
26359       {
26360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26361       };
26362     }
26363   }
26364   jresult = (void *)result;
26365   return jresult;
26366 }
26367
26368
26369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26370   float jresult ;
26371   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26372   std::size_t arg2 ;
26373   float result;
26374
26375   arg1 = (Dali::TouchData *)jarg1;
26376   arg2 = (std::size_t)jarg2;
26377   {
26378     try {
26379       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26380     } catch (std::out_of_range& e) {
26381       {
26382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26383       };
26384     } catch (std::exception& e) {
26385       {
26386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26387       };
26388     } catch (...) {
26389       {
26390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26391       };
26392     }
26393   }
26394   jresult = result;
26395   return jresult;
26396 }
26397
26398
26399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26400   void * jresult ;
26401   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26402   std::size_t arg2 ;
26403   Dali::Vector2 *result = 0 ;
26404
26405   arg1 = (Dali::TouchData *)jarg1;
26406   arg2 = (std::size_t)jarg2;
26407   {
26408     try {
26409       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26410     } catch (std::out_of_range& e) {
26411       {
26412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26413       };
26414     } catch (std::exception& e) {
26415       {
26416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26417       };
26418     } catch (...) {
26419       {
26420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26421       };
26422     }
26423   }
26424   jresult = (void *)result;
26425   return jresult;
26426 }
26427
26428
26429 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26430   float jresult ;
26431   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26432   std::size_t arg2 ;
26433   float result;
26434
26435   arg1 = (Dali::TouchData *)jarg1;
26436   arg2 = (std::size_t)jarg2;
26437   {
26438     try {
26439       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26440     } catch (std::out_of_range& e) {
26441       {
26442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26443       };
26444     } catch (std::exception& e) {
26445       {
26446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26447       };
26448     } catch (...) {
26449       {
26450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26451       };
26452     }
26453   }
26454   jresult = result;
26455   return jresult;
26456 }
26457
26458
26459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26460   void * jresult ;
26461   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26462   std::size_t arg2 ;
26463   Dali::Degree result;
26464
26465   arg1 = (Dali::TouchData *)jarg1;
26466   arg2 = (std::size_t)jarg2;
26467   {
26468     try {
26469       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26470     } catch (std::out_of_range& e) {
26471       {
26472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26473       };
26474     } catch (std::exception& e) {
26475       {
26476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26477       };
26478     } catch (...) {
26479       {
26480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26481       };
26482     }
26483   }
26484   jresult = new Dali::Degree((const Dali::Degree &)result);
26485   return jresult;
26486 }
26487
26488
26489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26490   void * jresult ;
26491   Dali::GestureDetector *result = 0 ;
26492
26493   {
26494     try {
26495       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26496     } catch (std::out_of_range& e) {
26497       {
26498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26499       };
26500     } catch (std::exception& e) {
26501       {
26502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26503       };
26504     } catch (...) {
26505       {
26506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26507       };
26508     }
26509   }
26510   jresult = (void *)result;
26511   return jresult;
26512 }
26513
26514
26515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26516   void * jresult ;
26517   Dali::BaseHandle arg1 ;
26518   Dali::BaseHandle *argp1 ;
26519   Dali::GestureDetector result;
26520
26521   argp1 = (Dali::BaseHandle *)jarg1;
26522   if (!argp1) {
26523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26524     return 0;
26525   }
26526   arg1 = *argp1;
26527   {
26528     try {
26529       result = Dali::GestureDetector::DownCast(arg1);
26530     } catch (std::out_of_range& e) {
26531       {
26532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26533       };
26534     } catch (std::exception& e) {
26535       {
26536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26537       };
26538     } catch (...) {
26539       {
26540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26541       };
26542     }
26543   }
26544   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26545   return jresult;
26546 }
26547
26548
26549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26550   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26551
26552   arg1 = (Dali::GestureDetector *)jarg1;
26553   {
26554     try {
26555       delete arg1;
26556     } catch (std::out_of_range& e) {
26557       {
26558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26559       };
26560     } catch (std::exception& e) {
26561       {
26562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26563       };
26564     } catch (...) {
26565       {
26566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26567       };
26568     }
26569   }
26570 }
26571
26572
26573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26574   void * jresult ;
26575   Dali::GestureDetector *arg1 = 0 ;
26576   Dali::GestureDetector *result = 0 ;
26577
26578   arg1 = (Dali::GestureDetector *)jarg1;
26579   if (!arg1) {
26580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26581     return 0;
26582   }
26583   {
26584     try {
26585       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26586     } catch (std::out_of_range& e) {
26587       {
26588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26589       };
26590     } catch (std::exception& e) {
26591       {
26592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26593       };
26594     } catch (...) {
26595       {
26596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26597       };
26598     }
26599   }
26600   jresult = (void *)result;
26601   return jresult;
26602 }
26603
26604
26605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26606   void * jresult ;
26607   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26608   Dali::GestureDetector *arg2 = 0 ;
26609   Dali::GestureDetector *result = 0 ;
26610
26611   arg1 = (Dali::GestureDetector *)jarg1;
26612   arg2 = (Dali::GestureDetector *)jarg2;
26613   if (!arg2) {
26614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26615     return 0;
26616   }
26617   {
26618     try {
26619       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26620     } catch (std::out_of_range& e) {
26621       {
26622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26623       };
26624     } catch (std::exception& e) {
26625       {
26626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26627       };
26628     } catch (...) {
26629       {
26630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26631       };
26632     }
26633   }
26634   jresult = (void *)result;
26635   return jresult;
26636 }
26637
26638
26639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26640   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26641   Dali::Actor arg2 ;
26642   Dali::Actor *argp2 ;
26643
26644   arg1 = (Dali::GestureDetector *)jarg1;
26645   argp2 = (Dali::Actor *)jarg2;
26646   if (!argp2) {
26647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26648     return ;
26649   }
26650   arg2 = *argp2;
26651   {
26652     try {
26653       (arg1)->Attach(arg2);
26654     } catch (std::out_of_range& e) {
26655       {
26656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26657       };
26658     } catch (std::exception& e) {
26659       {
26660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26661       };
26662     } catch (...) {
26663       {
26664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26665       };
26666     }
26667   }
26668 }
26669
26670
26671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26672   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26673   Dali::Actor arg2 ;
26674   Dali::Actor *argp2 ;
26675
26676   arg1 = (Dali::GestureDetector *)jarg1;
26677   argp2 = (Dali::Actor *)jarg2;
26678   if (!argp2) {
26679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26680     return ;
26681   }
26682   arg2 = *argp2;
26683   {
26684     try {
26685       (arg1)->Detach(arg2);
26686     } catch (std::out_of_range& e) {
26687       {
26688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26689       };
26690     } catch (std::exception& e) {
26691       {
26692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26693       };
26694     } catch (...) {
26695       {
26696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26697       };
26698     }
26699   }
26700 }
26701
26702
26703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26704   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26705
26706   arg1 = (Dali::GestureDetector *)jarg1;
26707   {
26708     try {
26709       (arg1)->DetachAll();
26710     } catch (std::out_of_range& e) {
26711       {
26712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26713       };
26714     } catch (std::exception& e) {
26715       {
26716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26717       };
26718     } catch (...) {
26719       {
26720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26721       };
26722     }
26723   }
26724 }
26725
26726
26727 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26728   unsigned long jresult ;
26729   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26730   size_t result;
26731
26732   arg1 = (Dali::GestureDetector *)jarg1;
26733   {
26734     try {
26735       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26736     } catch (std::out_of_range& e) {
26737       {
26738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26739       };
26740     } catch (std::exception& e) {
26741       {
26742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26743       };
26744     } catch (...) {
26745       {
26746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26747       };
26748     }
26749   }
26750   jresult = (unsigned long)result;
26751   return jresult;
26752 }
26753
26754
26755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26756   void * jresult ;
26757   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26758   size_t arg2 ;
26759   Dali::Actor result;
26760
26761   arg1 = (Dali::GestureDetector *)jarg1;
26762   arg2 = (size_t)jarg2;
26763   {
26764     try {
26765       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26766     } catch (std::out_of_range& e) {
26767       {
26768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26769       };
26770     } catch (std::exception& e) {
26771       {
26772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26773       };
26774     } catch (...) {
26775       {
26776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26777       };
26778     }
26779   }
26780   jresult = new Dali::Actor((const Dali::Actor &)result);
26781   return jresult;
26782 }
26783
26784
26785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26786   void * jresult ;
26787   Dali::Gesture *arg1 = 0 ;
26788   Dali::Gesture *result = 0 ;
26789
26790   arg1 = (Dali::Gesture *)jarg1;
26791   if (!arg1) {
26792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26793     return 0;
26794   }
26795   {
26796     try {
26797       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26798     } catch (std::out_of_range& e) {
26799       {
26800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26801       };
26802     } catch (std::exception& e) {
26803       {
26804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26805       };
26806     } catch (...) {
26807       {
26808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26809       };
26810     }
26811   }
26812   jresult = (void *)result;
26813   return jresult;
26814 }
26815
26816
26817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26818   void * jresult ;
26819   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26820   Dali::Gesture *arg2 = 0 ;
26821   Dali::Gesture *result = 0 ;
26822
26823   arg1 = (Dali::Gesture *)jarg1;
26824   arg2 = (Dali::Gesture *)jarg2;
26825   if (!arg2) {
26826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26827     return 0;
26828   }
26829   {
26830     try {
26831       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26832     } catch (std::out_of_range& e) {
26833       {
26834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26835       };
26836     } catch (std::exception& e) {
26837       {
26838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26839       };
26840     } catch (...) {
26841       {
26842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26843       };
26844     }
26845   }
26846   jresult = (void *)result;
26847   return jresult;
26848 }
26849
26850
26851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26852   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26853
26854   arg1 = (Dali::Gesture *)jarg1;
26855   {
26856     try {
26857       delete arg1;
26858     } catch (std::out_of_range& e) {
26859       {
26860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26861       };
26862     } catch (std::exception& e) {
26863       {
26864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26865       };
26866     } catch (...) {
26867       {
26868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26869       };
26870     }
26871   }
26872 }
26873
26874
26875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26876   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26877   Dali::Gesture::Type arg2 ;
26878
26879   arg1 = (Dali::Gesture *)jarg1;
26880   arg2 = (Dali::Gesture::Type)jarg2;
26881   if (arg1) (arg1)->type = arg2;
26882 }
26883
26884
26885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26886   int jresult ;
26887   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26888   Dali::Gesture::Type result;
26889
26890   arg1 = (Dali::Gesture *)jarg1;
26891   result = (Dali::Gesture::Type) ((arg1)->type);
26892   jresult = (int)result;
26893   return jresult;
26894 }
26895
26896
26897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
26898   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26899   Dali::Gesture::State arg2 ;
26900
26901   arg1 = (Dali::Gesture *)jarg1;
26902   arg2 = (Dali::Gesture::State)jarg2;
26903   if (arg1) (arg1)->state = arg2;
26904 }
26905
26906
26907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
26908   int jresult ;
26909   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26910   Dali::Gesture::State result;
26911
26912   arg1 = (Dali::Gesture *)jarg1;
26913   result = (Dali::Gesture::State) ((arg1)->state);
26914   jresult = (int)result;
26915   return jresult;
26916 }
26917
26918
26919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
26920   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26921   unsigned int arg2 ;
26922
26923   arg1 = (Dali::Gesture *)jarg1;
26924   arg2 = (unsigned int)jarg2;
26925   if (arg1) (arg1)->time = arg2;
26926 }
26927
26928
26929 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
26930   unsigned int jresult ;
26931   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26932   unsigned int result;
26933
26934   arg1 = (Dali::Gesture *)jarg1;
26935   result = (unsigned int) ((arg1)->time);
26936   jresult = result;
26937   return jresult;
26938 }
26939
26940
26941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
26942   void * jresult ;
26943   Dali::HoverEvent *result = 0 ;
26944
26945   {
26946     try {
26947       result = (Dali::HoverEvent *)new Dali::HoverEvent();
26948     } catch (std::out_of_range& e) {
26949       {
26950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26951       };
26952     } catch (std::exception& e) {
26953       {
26954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26955       };
26956     } catch (...) {
26957       {
26958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26959       };
26960     }
26961   }
26962   jresult = (void *)result;
26963   return jresult;
26964 }
26965
26966
26967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
26968   void * jresult ;
26969   unsigned long arg1 ;
26970   Dali::HoverEvent *result = 0 ;
26971
26972   arg1 = (unsigned long)jarg1;
26973   {
26974     try {
26975       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
26976     } catch (std::out_of_range& e) {
26977       {
26978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26979       };
26980     } catch (std::exception& e) {
26981       {
26982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26983       };
26984     } catch (...) {
26985       {
26986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26987       };
26988     }
26989   }
26990   jresult = (void *)result;
26991   return jresult;
26992 }
26993
26994
26995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
26996   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26997
26998   arg1 = (Dali::HoverEvent *)jarg1;
26999   {
27000     try {
27001       delete arg1;
27002     } catch (std::out_of_range& e) {
27003       {
27004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27005       };
27006     } catch (std::exception& e) {
27007       {
27008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27009       };
27010     } catch (...) {
27011       {
27012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27013       };
27014     }
27015   }
27016 }
27017
27018
27019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27020   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27021   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27022
27023   arg1 = (Dali::HoverEvent *)jarg1;
27024   arg2 = (Dali::TouchPointContainer *)jarg2;
27025   if (arg1) (arg1)->points = *arg2;
27026 }
27027
27028
27029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27030   void * jresult ;
27031   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27032   Dali::TouchPointContainer *result = 0 ;
27033
27034   arg1 = (Dali::HoverEvent *)jarg1;
27035   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27036   jresult = (void *)result;
27037   return jresult;
27038 }
27039
27040
27041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27042   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27043   unsigned long arg2 ;
27044
27045   arg1 = (Dali::HoverEvent *)jarg1;
27046   arg2 = (unsigned long)jarg2;
27047   if (arg1) (arg1)->time = arg2;
27048 }
27049
27050
27051 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27052   unsigned long jresult ;
27053   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27054   unsigned long result;
27055
27056   arg1 = (Dali::HoverEvent *)jarg1;
27057   result = (unsigned long) ((arg1)->time);
27058   jresult = (unsigned long)result;
27059   return jresult;
27060 }
27061
27062
27063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27064   unsigned int jresult ;
27065   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27066   unsigned int result;
27067
27068   arg1 = (Dali::HoverEvent *)jarg1;
27069   {
27070     try {
27071       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27072     } catch (std::out_of_range& e) {
27073       {
27074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27075       };
27076     } catch (std::exception& e) {
27077       {
27078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27079       };
27080     } catch (...) {
27081       {
27082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27083       };
27084     }
27085   }
27086   jresult = result;
27087   return jresult;
27088 }
27089
27090
27091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27092   void * jresult ;
27093   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27094   unsigned int arg2 ;
27095   Dali::TouchPoint *result = 0 ;
27096
27097   arg1 = (Dali::HoverEvent *)jarg1;
27098   arg2 = (unsigned int)jarg2;
27099   {
27100     try {
27101       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27102     } catch (std::out_of_range& e) {
27103       {
27104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27105       };
27106     } catch (std::exception& e) {
27107       {
27108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27109       };
27110     } catch (...) {
27111       {
27112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27113       };
27114     }
27115   }
27116   jresult = (void *)result;
27117   return jresult;
27118 }
27119
27120
27121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27122   void * jresult ;
27123   Dali::KeyEvent *result = 0 ;
27124
27125   {
27126     try {
27127       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27128     } catch (std::out_of_range& e) {
27129       {
27130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27131       };
27132     } catch (std::exception& e) {
27133       {
27134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27135       };
27136     } catch (...) {
27137       {
27138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27139       };
27140     }
27141   }
27142   jresult = (void *)result;
27143   return jresult;
27144 }
27145
27146
27147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27148   void * jresult ;
27149   std::string *arg1 = 0 ;
27150   std::string *arg2 = 0 ;
27151   int arg3 ;
27152   int arg4 ;
27153   unsigned long arg5 ;
27154   Dali::KeyEvent::State *arg6 = 0 ;
27155   Dali::KeyEvent::State temp6 ;
27156   Dali::KeyEvent *result = 0 ;
27157
27158   if (!jarg1) {
27159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27160     return 0;
27161   }
27162   std::string arg1_str(jarg1);
27163   arg1 = &arg1_str;
27164   if (!jarg2) {
27165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27166     return 0;
27167   }
27168   std::string arg2_str(jarg2);
27169   arg2 = &arg2_str;
27170   arg3 = (int)jarg3;
27171   arg4 = (int)jarg4;
27172   arg5 = (unsigned long)jarg5;
27173   temp6 = (Dali::KeyEvent::State)jarg6;
27174   arg6 = &temp6;
27175   {
27176     try {
27177       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27178     } catch (std::out_of_range& e) {
27179       {
27180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27181       };
27182     } catch (std::exception& e) {
27183       {
27184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27185       };
27186     } catch (...) {
27187       {
27188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27189       };
27190     }
27191   }
27192   jresult = (void *)result;
27193
27194   //argout typemap for const std::string&
27195
27196
27197   //argout typemap for const std::string&
27198
27199   return jresult;
27200 }
27201
27202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
27203   void * jresult ;
27204   Dali::KeyEvent *arg1 = 0 ;
27205   Dali::KeyEvent *result = 0 ;
27206
27207   arg1 = (Dali::KeyEvent *)jarg1;
27208   if (!arg1) {
27209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27210     return 0;
27211   }
27212   {
27213     try {
27214       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
27215     } catch (std::out_of_range& e) {
27216       {
27217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27218       };
27219     } catch (std::exception& e) {
27220       {
27221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27222       };
27223     } catch (...) {
27224       {
27225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27226       };
27227     }
27228   }
27229   jresult = (void *)result;
27230   return jresult;
27231 }
27232
27233
27234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
27235   void * jresult ;
27236   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27237   Dali::KeyEvent *arg2 = 0 ;
27238   Dali::KeyEvent *result = 0 ;
27239
27240   arg1 = (Dali::KeyEvent *)jarg1;
27241   arg2 = (Dali::KeyEvent *)jarg2;
27242   if (!arg2) {
27243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27244     return 0;
27245   }
27246   {
27247     try {
27248       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
27249     } catch (std::out_of_range& e) {
27250       {
27251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27252       };
27253     } catch (std::exception& e) {
27254       {
27255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27256       };
27257     } catch (...) {
27258       {
27259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27260       };
27261     }
27262   }
27263   jresult = (void *)result;
27264   return jresult;
27265 }
27266
27267
27268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27269   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27270
27271   arg1 = (Dali::KeyEvent *)jarg1;
27272   {
27273     try {
27274       delete arg1;
27275     } catch (std::out_of_range& e) {
27276       {
27277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27278       };
27279     } catch (std::exception& e) {
27280       {
27281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27282       };
27283     } catch (...) {
27284       {
27285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27286       };
27287     }
27288   }
27289 }
27290
27291
27292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27293   unsigned int jresult ;
27294   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27295   bool result;
27296
27297   arg1 = (Dali::KeyEvent *)jarg1;
27298   {
27299     try {
27300       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27301     } catch (std::out_of_range& e) {
27302       {
27303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27304       };
27305     } catch (std::exception& e) {
27306       {
27307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27308       };
27309     } catch (...) {
27310       {
27311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27312       };
27313     }
27314   }
27315   jresult = result;
27316   return jresult;
27317 }
27318
27319
27320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27321   unsigned int jresult ;
27322   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27323   bool result;
27324
27325   arg1 = (Dali::KeyEvent *)jarg1;
27326   {
27327     try {
27328       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
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 = result;
27344   return jresult;
27345 }
27346
27347
27348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27349   unsigned int jresult ;
27350   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27351   bool result;
27352
27353   arg1 = (Dali::KeyEvent *)jarg1;
27354   {
27355     try {
27356       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27357     } catch (std::out_of_range& e) {
27358       {
27359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27360       };
27361     } catch (std::exception& e) {
27362       {
27363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27364       };
27365     } catch (...) {
27366       {
27367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27368       };
27369     }
27370   }
27371   jresult = result;
27372   return jresult;
27373 }
27374
27375
27376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27377   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27378   std::string *arg2 = 0 ;
27379
27380   arg1 = (Dali::KeyEvent *)jarg1;
27381   if (!jarg2) {
27382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27383     return ;
27384   }
27385   std::string arg2_str(jarg2);
27386   arg2 = &arg2_str;
27387   if (arg1) (arg1)->keyPressedName = *arg2;
27388
27389   //argout typemap for const std::string&
27390
27391 }
27392
27393
27394 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27395   char * jresult ;
27396   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27397   std::string *result = 0 ;
27398
27399   arg1 = (Dali::KeyEvent *)jarg1;
27400   result = (std::string *) & ((arg1)->keyPressedName);
27401   jresult = SWIG_csharp_string_callback(result->c_str());
27402   return jresult;
27403 }
27404
27405
27406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27407   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27408   std::string *arg2 = 0 ;
27409
27410   arg1 = (Dali::KeyEvent *)jarg1;
27411   if (!jarg2) {
27412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27413     return ;
27414   }
27415   std::string arg2_str(jarg2);
27416   arg2 = &arg2_str;
27417   if (arg1) (arg1)->keyPressed = *arg2;
27418
27419   //argout typemap for const std::string&
27420
27421 }
27422
27423
27424 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27425   char * jresult ;
27426   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27427   std::string *result = 0 ;
27428
27429   arg1 = (Dali::KeyEvent *)jarg1;
27430   result = (std::string *) & ((arg1)->keyPressed);
27431   jresult = SWIG_csharp_string_callback(result->c_str());
27432   return jresult;
27433 }
27434
27435
27436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27437   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27438   int arg2 ;
27439
27440   arg1 = (Dali::KeyEvent *)jarg1;
27441   arg2 = (int)jarg2;
27442   if (arg1) (arg1)->keyCode = arg2;
27443 }
27444
27445
27446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27447   int jresult ;
27448   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27449   int result;
27450
27451   arg1 = (Dali::KeyEvent *)jarg1;
27452   result = (int) ((arg1)->keyCode);
27453   jresult = result;
27454   return jresult;
27455 }
27456
27457
27458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27459   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27460   int arg2 ;
27461
27462   arg1 = (Dali::KeyEvent *)jarg1;
27463   arg2 = (int)jarg2;
27464   if (arg1) (arg1)->keyModifier = arg2;
27465 }
27466
27467
27468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27469   int jresult ;
27470   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27471   int result;
27472
27473   arg1 = (Dali::KeyEvent *)jarg1;
27474   result = (int) ((arg1)->keyModifier);
27475   jresult = result;
27476   return jresult;
27477 }
27478
27479
27480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27481   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27482   unsigned long arg2 ;
27483
27484   arg1 = (Dali::KeyEvent *)jarg1;
27485   arg2 = (unsigned long)jarg2;
27486   if (arg1) (arg1)->time = arg2;
27487 }
27488
27489
27490 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27491   unsigned long jresult ;
27492   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27493   unsigned long result;
27494
27495   arg1 = (Dali::KeyEvent *)jarg1;
27496   result = (unsigned long) ((arg1)->time);
27497   jresult = (unsigned long)result;
27498   return jresult;
27499 }
27500
27501
27502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27503   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27504   Dali::KeyEvent::State arg2 ;
27505
27506   arg1 = (Dali::KeyEvent *)jarg1;
27507   arg2 = (Dali::KeyEvent::State)jarg2;
27508   if (arg1) (arg1)->state = arg2;
27509 }
27510
27511
27512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27513   int jresult ;
27514   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27515   Dali::KeyEvent::State result;
27516
27517   arg1 = (Dali::KeyEvent *)jarg1;
27518   result = (Dali::KeyEvent::State) ((arg1)->state);
27519   jresult = (int)result;
27520   return jresult;
27521 }
27522
27523
27524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27525   void * jresult ;
27526   Dali::LongPressGestureDetector *result = 0 ;
27527
27528   {
27529     try {
27530       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27531     } catch (std::out_of_range& e) {
27532       {
27533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27534       };
27535     } catch (std::exception& e) {
27536       {
27537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27538       };
27539     } catch (...) {
27540       {
27541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27542       };
27543     }
27544   }
27545   jresult = (void *)result;
27546   return jresult;
27547 }
27548
27549
27550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27551   void * jresult ;
27552   Dali::LongPressGestureDetector result;
27553
27554   {
27555     try {
27556       result = Dali::LongPressGestureDetector::New();
27557     } catch (std::out_of_range& e) {
27558       {
27559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27560       };
27561     } catch (std::exception& e) {
27562       {
27563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27564       };
27565     } catch (...) {
27566       {
27567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27568       };
27569     }
27570   }
27571   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27572   return jresult;
27573 }
27574
27575
27576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27577   void * jresult ;
27578   unsigned int arg1 ;
27579   Dali::LongPressGestureDetector result;
27580
27581   arg1 = (unsigned int)jarg1;
27582   {
27583     try {
27584       result = Dali::LongPressGestureDetector::New(arg1);
27585     } catch (std::out_of_range& e) {
27586       {
27587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27588       };
27589     } catch (std::exception& e) {
27590       {
27591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27592       };
27593     } catch (...) {
27594       {
27595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27596       };
27597     }
27598   }
27599   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27600   return jresult;
27601 }
27602
27603
27604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27605   void * jresult ;
27606   unsigned int arg1 ;
27607   unsigned int arg2 ;
27608   Dali::LongPressGestureDetector result;
27609
27610   arg1 = (unsigned int)jarg1;
27611   arg2 = (unsigned int)jarg2;
27612   {
27613     try {
27614       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27615     } catch (std::out_of_range& e) {
27616       {
27617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27618       };
27619     } catch (std::exception& e) {
27620       {
27621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27622       };
27623     } catch (...) {
27624       {
27625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27626       };
27627     }
27628   }
27629   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27630   return jresult;
27631 }
27632
27633
27634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27635   void * jresult ;
27636   Dali::BaseHandle arg1 ;
27637   Dali::BaseHandle *argp1 ;
27638   Dali::LongPressGestureDetector result;
27639
27640   argp1 = (Dali::BaseHandle *)jarg1;
27641   if (!argp1) {
27642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27643     return 0;
27644   }
27645   arg1 = *argp1;
27646   {
27647     try {
27648       result = Dali::LongPressGestureDetector::DownCast(arg1);
27649     } catch (std::out_of_range& e) {
27650       {
27651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27652       };
27653     } catch (std::exception& e) {
27654       {
27655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27656       };
27657     } catch (...) {
27658       {
27659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27660       };
27661     }
27662   }
27663   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27664   return jresult;
27665 }
27666
27667
27668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27669   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27670
27671   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27672   {
27673     try {
27674       delete arg1;
27675     } catch (std::out_of_range& e) {
27676       {
27677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27678       };
27679     } catch (std::exception& e) {
27680       {
27681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27682       };
27683     } catch (...) {
27684       {
27685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27686       };
27687     }
27688   }
27689 }
27690
27691
27692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27693   void * jresult ;
27694   Dali::LongPressGestureDetector *arg1 = 0 ;
27695   Dali::LongPressGestureDetector *result = 0 ;
27696
27697   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27698   if (!arg1) {
27699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27700     return 0;
27701   }
27702   {
27703     try {
27704       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27705     } catch (std::out_of_range& e) {
27706       {
27707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27708       };
27709     } catch (std::exception& e) {
27710       {
27711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27712       };
27713     } catch (...) {
27714       {
27715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27716       };
27717     }
27718   }
27719   jresult = (void *)result;
27720   return jresult;
27721 }
27722
27723
27724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27725   void * jresult ;
27726   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27727   Dali::LongPressGestureDetector *arg2 = 0 ;
27728   Dali::LongPressGestureDetector *result = 0 ;
27729
27730   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27731   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27732   if (!arg2) {
27733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27734     return 0;
27735   }
27736   {
27737     try {
27738       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27739     } catch (std::out_of_range& e) {
27740       {
27741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27742       };
27743     } catch (std::exception& e) {
27744       {
27745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27746       };
27747     } catch (...) {
27748       {
27749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27750       };
27751     }
27752   }
27753   jresult = (void *)result;
27754   return jresult;
27755 }
27756
27757
27758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27759   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27760   unsigned int arg2 ;
27761
27762   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27763   arg2 = (unsigned int)jarg2;
27764   {
27765     try {
27766       (arg1)->SetTouchesRequired(arg2);
27767     } catch (std::out_of_range& e) {
27768       {
27769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27770       };
27771     } catch (std::exception& e) {
27772       {
27773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27774       };
27775     } catch (...) {
27776       {
27777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27778       };
27779     }
27780   }
27781 }
27782
27783
27784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27785   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27786   unsigned int arg2 ;
27787   unsigned int arg3 ;
27788
27789   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27790   arg2 = (unsigned int)jarg2;
27791   arg3 = (unsigned int)jarg3;
27792   {
27793     try {
27794       (arg1)->SetTouchesRequired(arg2,arg3);
27795     } catch (std::out_of_range& e) {
27796       {
27797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27798       };
27799     } catch (std::exception& e) {
27800       {
27801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27802       };
27803     } catch (...) {
27804       {
27805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27806       };
27807     }
27808   }
27809 }
27810
27811
27812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27813   unsigned int jresult ;
27814   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27815   unsigned int result;
27816
27817   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27818   {
27819     try {
27820       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27821     } catch (std::out_of_range& e) {
27822       {
27823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27824       };
27825     } catch (std::exception& e) {
27826       {
27827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27828       };
27829     } catch (...) {
27830       {
27831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27832       };
27833     }
27834   }
27835   jresult = result;
27836   return jresult;
27837 }
27838
27839
27840 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27841   unsigned int jresult ;
27842   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27843   unsigned int result;
27844
27845   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27846   {
27847     try {
27848       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27849     } catch (std::out_of_range& e) {
27850       {
27851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27852       };
27853     } catch (std::exception& e) {
27854       {
27855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27856       };
27857     } catch (...) {
27858       {
27859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27860       };
27861     }
27862   }
27863   jresult = result;
27864   return jresult;
27865 }
27866
27867
27868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27869   void * jresult ;
27870   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27871   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27872
27873   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27874   {
27875     try {
27876       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27877     } catch (std::out_of_range& e) {
27878       {
27879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27880       };
27881     } catch (std::exception& e) {
27882       {
27883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27884       };
27885     } catch (...) {
27886       {
27887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27888       };
27889     }
27890   }
27891   jresult = (void *)result;
27892   return jresult;
27893 }
27894
27895
27896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27897   void * jresult ;
27898   Dali::Gesture::State arg1 ;
27899   Dali::LongPressGesture *result = 0 ;
27900
27901   arg1 = (Dali::Gesture::State)jarg1;
27902   {
27903     try {
27904       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27905     } catch (std::out_of_range& e) {
27906       {
27907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27908       };
27909     } catch (std::exception& e) {
27910       {
27911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27912       };
27913     } catch (...) {
27914       {
27915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27916       };
27917     }
27918   }
27919   jresult = (void *)result;
27920   return jresult;
27921 }
27922
27923
27924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
27925   void * jresult ;
27926   Dali::LongPressGesture *arg1 = 0 ;
27927   Dali::LongPressGesture *result = 0 ;
27928
27929   arg1 = (Dali::LongPressGesture *)jarg1;
27930   if (!arg1) {
27931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27932     return 0;
27933   }
27934   {
27935     try {
27936       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
27937     } catch (std::out_of_range& e) {
27938       {
27939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27940       };
27941     } catch (std::exception& e) {
27942       {
27943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27944       };
27945     } catch (...) {
27946       {
27947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27948       };
27949     }
27950   }
27951   jresult = (void *)result;
27952   return jresult;
27953 }
27954
27955
27956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
27957   void * jresult ;
27958   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27959   Dali::LongPressGesture *arg2 = 0 ;
27960   Dali::LongPressGesture *result = 0 ;
27961
27962   arg1 = (Dali::LongPressGesture *)jarg1;
27963   arg2 = (Dali::LongPressGesture *)jarg2;
27964   if (!arg2) {
27965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27966     return 0;
27967   }
27968   {
27969     try {
27970       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
27971     } catch (std::out_of_range& e) {
27972       {
27973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27974       };
27975     } catch (std::exception& e) {
27976       {
27977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27978       };
27979     } catch (...) {
27980       {
27981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27982       };
27983     }
27984   }
27985   jresult = (void *)result;
27986   return jresult;
27987 }
27988
27989
27990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
27991   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27992
27993   arg1 = (Dali::LongPressGesture *)jarg1;
27994   {
27995     try {
27996       delete arg1;
27997     } catch (std::out_of_range& e) {
27998       {
27999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28000       };
28001     } catch (std::exception& e) {
28002       {
28003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28004       };
28005     } catch (...) {
28006       {
28007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28008       };
28009     }
28010   }
28011 }
28012
28013
28014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28015   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28016   unsigned int arg2 ;
28017
28018   arg1 = (Dali::LongPressGesture *)jarg1;
28019   arg2 = (unsigned int)jarg2;
28020   if (arg1) (arg1)->numberOfTouches = arg2;
28021 }
28022
28023
28024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28025   unsigned int jresult ;
28026   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28027   unsigned int result;
28028
28029   arg1 = (Dali::LongPressGesture *)jarg1;
28030   result = (unsigned int) ((arg1)->numberOfTouches);
28031   jresult = result;
28032   return jresult;
28033 }
28034
28035
28036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28037   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28038   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28039
28040   arg1 = (Dali::LongPressGesture *)jarg1;
28041   arg2 = (Dali::Vector2 *)jarg2;
28042   if (arg1) (arg1)->screenPoint = *arg2;
28043 }
28044
28045
28046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28047   void * jresult ;
28048   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28049   Dali::Vector2 *result = 0 ;
28050
28051   arg1 = (Dali::LongPressGesture *)jarg1;
28052   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28053   jresult = (void *)result;
28054   return jresult;
28055 }
28056
28057
28058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28059   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28060   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28061
28062   arg1 = (Dali::LongPressGesture *)jarg1;
28063   arg2 = (Dali::Vector2 *)jarg2;
28064   if (arg1) (arg1)->localPoint = *arg2;
28065 }
28066
28067
28068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28069   void * jresult ;
28070   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28071   Dali::Vector2 *result = 0 ;
28072
28073   arg1 = (Dali::LongPressGesture *)jarg1;
28074   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28075   jresult = (void *)result;
28076   return jresult;
28077 }
28078
28079
28080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28081   void * jresult ;
28082   Dali::WheelEvent *result = 0 ;
28083
28084   {
28085     try {
28086       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28087     } catch (std::out_of_range& e) {
28088       {
28089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28090       };
28091     } catch (std::exception& e) {
28092       {
28093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28094       };
28095     } catch (...) {
28096       {
28097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28098       };
28099     }
28100   }
28101   jresult = (void *)result;
28102   return jresult;
28103 }
28104
28105
28106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28107   void * jresult ;
28108   Dali::WheelEvent::Type arg1 ;
28109   int arg2 ;
28110   unsigned int arg3 ;
28111   Dali::Vector2 arg4 ;
28112   int arg5 ;
28113   unsigned int arg6 ;
28114   Dali::Vector2 *argp4 ;
28115   Dali::WheelEvent *result = 0 ;
28116
28117   arg1 = (Dali::WheelEvent::Type)jarg1;
28118   arg2 = (int)jarg2;
28119   arg3 = (unsigned int)jarg3;
28120   argp4 = (Dali::Vector2 *)jarg4;
28121   if (!argp4) {
28122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28123     return 0;
28124   }
28125   arg4 = *argp4;
28126   arg5 = (int)jarg5;
28127   arg6 = (unsigned int)jarg6;
28128   {
28129     try {
28130       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28131     } catch (std::out_of_range& e) {
28132       {
28133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28134       };
28135     } catch (std::exception& e) {
28136       {
28137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28138       };
28139     } catch (...) {
28140       {
28141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28142       };
28143     }
28144   }
28145   jresult = (void *)result;
28146   return jresult;
28147 }
28148
28149
28150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28151   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28152
28153   arg1 = (Dali::WheelEvent *)jarg1;
28154   {
28155     try {
28156       delete arg1;
28157     } catch (std::out_of_range& e) {
28158       {
28159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28160       };
28161     } catch (std::exception& e) {
28162       {
28163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28164       };
28165     } catch (...) {
28166       {
28167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28168       };
28169     }
28170   }
28171 }
28172
28173
28174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28175   unsigned int jresult ;
28176   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28177   bool result;
28178
28179   arg1 = (Dali::WheelEvent *)jarg1;
28180   {
28181     try {
28182       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28183     } catch (std::out_of_range& e) {
28184       {
28185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28186       };
28187     } catch (std::exception& e) {
28188       {
28189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28190       };
28191     } catch (...) {
28192       {
28193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28194       };
28195     }
28196   }
28197   jresult = result;
28198   return jresult;
28199 }
28200
28201
28202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28203   unsigned int jresult ;
28204   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28205   bool result;
28206
28207   arg1 = (Dali::WheelEvent *)jarg1;
28208   {
28209     try {
28210       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
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 = result;
28226   return jresult;
28227 }
28228
28229
28230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28231   unsigned int jresult ;
28232   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28233   bool result;
28234
28235   arg1 = (Dali::WheelEvent *)jarg1;
28236   {
28237     try {
28238       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28239     } catch (std::out_of_range& e) {
28240       {
28241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28242       };
28243     } catch (std::exception& e) {
28244       {
28245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28246       };
28247     } catch (...) {
28248       {
28249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28250       };
28251     }
28252   }
28253   jresult = result;
28254   return jresult;
28255 }
28256
28257
28258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28259   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28260   Dali::WheelEvent::Type arg2 ;
28261
28262   arg1 = (Dali::WheelEvent *)jarg1;
28263   arg2 = (Dali::WheelEvent::Type)jarg2;
28264   if (arg1) (arg1)->type = arg2;
28265 }
28266
28267
28268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28269   int jresult ;
28270   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28271   Dali::WheelEvent::Type result;
28272
28273   arg1 = (Dali::WheelEvent *)jarg1;
28274   result = (Dali::WheelEvent::Type) ((arg1)->type);
28275   jresult = (int)result;
28276   return jresult;
28277 }
28278
28279
28280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28281   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28282   int arg2 ;
28283
28284   arg1 = (Dali::WheelEvent *)jarg1;
28285   arg2 = (int)jarg2;
28286   if (arg1) (arg1)->direction = arg2;
28287 }
28288
28289
28290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28291   int jresult ;
28292   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28293   int result;
28294
28295   arg1 = (Dali::WheelEvent *)jarg1;
28296   result = (int) ((arg1)->direction);
28297   jresult = result;
28298   return jresult;
28299 }
28300
28301
28302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28303   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28304   unsigned int arg2 ;
28305
28306   arg1 = (Dali::WheelEvent *)jarg1;
28307   arg2 = (unsigned int)jarg2;
28308   if (arg1) (arg1)->modifiers = arg2;
28309 }
28310
28311
28312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28313   unsigned int jresult ;
28314   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28315   unsigned int result;
28316
28317   arg1 = (Dali::WheelEvent *)jarg1;
28318   result = (unsigned int) ((arg1)->modifiers);
28319   jresult = result;
28320   return jresult;
28321 }
28322
28323
28324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28325   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28326   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28327
28328   arg1 = (Dali::WheelEvent *)jarg1;
28329   arg2 = (Dali::Vector2 *)jarg2;
28330   if (arg1) (arg1)->point = *arg2;
28331 }
28332
28333
28334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28335   void * jresult ;
28336   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28337   Dali::Vector2 *result = 0 ;
28338
28339   arg1 = (Dali::WheelEvent *)jarg1;
28340   result = (Dali::Vector2 *)& ((arg1)->point);
28341   jresult = (void *)result;
28342   return jresult;
28343 }
28344
28345
28346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28347   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28348   int arg2 ;
28349
28350   arg1 = (Dali::WheelEvent *)jarg1;
28351   arg2 = (int)jarg2;
28352   if (arg1) (arg1)->z = arg2;
28353 }
28354
28355
28356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28357   int jresult ;
28358   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28359   int result;
28360
28361   arg1 = (Dali::WheelEvent *)jarg1;
28362   result = (int) ((arg1)->z);
28363   jresult = result;
28364   return jresult;
28365 }
28366
28367
28368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28369   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28370   unsigned int arg2 ;
28371
28372   arg1 = (Dali::WheelEvent *)jarg1;
28373   arg2 = (unsigned int)jarg2;
28374   if (arg1) (arg1)->timeStamp = arg2;
28375 }
28376
28377
28378 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28379   unsigned int jresult ;
28380   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28381   unsigned int result;
28382
28383   arg1 = (Dali::WheelEvent *)jarg1;
28384   result = (unsigned int) ((arg1)->timeStamp);
28385   jresult = result;
28386   return jresult;
28387 }
28388
28389 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
28390   char * jresult ;
28391   Dali::KeyEvent *arg1 = 0 ;
28392   std::string result;
28393
28394   arg1 = (Dali::KeyEvent *)jarg1;
28395   if (!arg1) {
28396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28397     return 0;
28398   }
28399   {
28400     try {
28401       result = arg1->GetDeviceName();
28402     } catch (std::out_of_range& e) {
28403       {
28404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28405       };
28406     } catch (std::exception& e) {
28407       {
28408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28409       };
28410     } catch (...) {
28411       {
28412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28413       };
28414     }
28415   }
28416   jresult = SWIG_csharp_string_callback((&result)->c_str());
28417   return jresult;
28418 }
28419
28420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
28421   int jresult ;
28422   Dali::KeyEvent *arg1 = 0 ;
28423   Dali::Device::Class::Type result;
28424
28425   arg1 = (Dali::KeyEvent *)jarg1;
28426   if (!arg1) {
28427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28428     return 0;
28429   }
28430   {
28431     try {
28432       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
28433     } catch (std::out_of_range& e) {
28434       {
28435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28436       };
28437     } catch (std::exception& e) {
28438       {
28439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28440       };
28441     } catch (...) {
28442       {
28443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28444       };
28445     }
28446   }
28447   jresult = (int)result;
28448   return jresult;
28449 }
28450
28451
28452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
28453   Dali::Actor arg1 ;
28454   Dali::Actor *argp1 ;
28455
28456   argp1 = (Dali::Actor *)jarg1;
28457   if (!argp1) {
28458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28459     return ;
28460   }
28461   arg1 = *argp1;
28462   {
28463     try {
28464       arg1.Raise();
28465     } catch (std::out_of_range& e) {
28466       {
28467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28468       };
28469     } catch (std::exception& e) {
28470       {
28471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28472       };
28473     } catch (...) {
28474       {
28475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28476       };
28477     }
28478   }
28479 }
28480
28481
28482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
28483   Dali::Actor arg1 ;
28484   Dali::Actor *argp1 ;
28485
28486   argp1 = (Dali::Actor *)jarg1;
28487   if (!argp1) {
28488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28489     return ;
28490   }
28491   arg1 = *argp1;
28492   {
28493     try {
28494       arg1.Lower();
28495     } catch (std::out_of_range& e) {
28496       {
28497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28498       };
28499     } catch (std::exception& e) {
28500       {
28501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28502       };
28503     } catch (...) {
28504       {
28505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28506       };
28507     }
28508   }
28509 }
28510
28511
28512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
28513   Dali::Actor arg1 ;
28514   Dali::Actor *argp1 ;
28515
28516   argp1 = (Dali::Actor *)jarg1;
28517   if (!argp1) {
28518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28519     return ;
28520   }
28521   arg1 = *argp1;
28522   {
28523     try {
28524       arg1.RaiseToTop();
28525     } catch (std::out_of_range& e) {
28526       {
28527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28528       };
28529     } catch (std::exception& e) {
28530       {
28531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28532       };
28533     } catch (...) {
28534       {
28535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28536       };
28537     }
28538   }
28539 }
28540
28541
28542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
28543   Dali::Actor arg1 ;
28544   Dali::Actor *argp1 ;
28545
28546   argp1 = (Dali::Actor *)jarg1;
28547   if (!argp1) {
28548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28549     return ;
28550   }
28551   arg1 = *argp1;
28552   {
28553     try {
28554       arg1.LowerToBottom();
28555     } catch (std::out_of_range& e) {
28556       {
28557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28558       };
28559     } catch (std::exception& e) {
28560       {
28561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28562       };
28563     } catch (...) {
28564       {
28565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28566       };
28567     }
28568   }
28569 }
28570
28571
28572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
28573   Dali::Actor arg1 ;
28574   Dali::Actor arg2 ;
28575   Dali::Actor *argp1 ;
28576   Dali::Actor *argp2 ;
28577
28578   argp1 = (Dali::Actor *)jarg1;
28579   if (!argp1) {
28580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28581     return ;
28582   }
28583   arg1 = *argp1;
28584   argp2 = (Dali::Actor *)jarg2;
28585   if (!argp2) {
28586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28587     return ;
28588   }
28589   arg2 = *argp2;
28590   {
28591     try {
28592       arg1.RaiseAbove(arg2);
28593     } catch (std::out_of_range& e) {
28594       {
28595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28596       };
28597     } catch (std::exception& e) {
28598       {
28599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28600       };
28601     } catch (...) {
28602       {
28603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28604       };
28605     }
28606   }
28607 }
28608
28609
28610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
28611   Dali::Actor arg1 ;
28612   Dali::Actor arg2 ;
28613   Dali::Actor *argp1 ;
28614   Dali::Actor *argp2 ;
28615
28616   argp1 = (Dali::Actor *)jarg1;
28617   if (!argp1) {
28618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28619     return ;
28620   }
28621   arg1 = *argp1;
28622   argp2 = (Dali::Actor *)jarg2;
28623   if (!argp2) {
28624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28625     return ;
28626   }
28627   arg2 = *argp2;
28628   {
28629     try {
28630       arg1.LowerBelow(arg2);
28631     } catch (std::out_of_range& e) {
28632       {
28633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28634       };
28635     } catch (std::exception& e) {
28636       {
28637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28638       };
28639     } catch (...) {
28640       {
28641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28642       };
28643     }
28644   }
28645 }
28646
28647
28648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
28649   void * jresult ;
28650   Dali::Actor arg1 ;
28651   Dali::Actor *argp1 ;
28652   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
28653
28654   argp1 = (Dali::Actor *)jarg1;
28655   if (!argp1) {
28656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28657     return 0;
28658   }
28659   arg1 = *argp1;
28660   {
28661     try {
28662       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
28663     } catch (std::out_of_range& e) {
28664       {
28665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28666       };
28667     } catch (std::exception& e) {
28668       {
28669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28670       };
28671     } catch (...) {
28672       {
28673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28674       };
28675     }
28676   }
28677   jresult = (void *)result;
28678   return jresult;
28679 }
28680
28681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28682   int jresult ;
28683   int result;
28684
28685   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28686   jresult = (int)result;
28687   return jresult;
28688 }
28689
28690
28691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28692   int jresult ;
28693   int result;
28694
28695   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28696   jresult = (int)result;
28697   return jresult;
28698 }
28699
28700
28701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28702   int jresult ;
28703   int result;
28704
28705   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28706   jresult = (int)result;
28707   return jresult;
28708 }
28709
28710
28711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28712   int jresult ;
28713   int result;
28714
28715   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28716   jresult = (int)result;
28717   return jresult;
28718 }
28719
28720
28721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28722   int jresult ;
28723   int result;
28724
28725   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28726   jresult = (int)result;
28727   return jresult;
28728 }
28729
28730
28731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28732   int jresult ;
28733   int result;
28734
28735   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28736   jresult = (int)result;
28737   return jresult;
28738 }
28739
28740
28741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28742   int jresult ;
28743   int result;
28744
28745   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28746   jresult = (int)result;
28747   return jresult;
28748 }
28749
28750
28751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28752   int jresult ;
28753   int result;
28754
28755   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28756   jresult = (int)result;
28757   return jresult;
28758 }
28759
28760
28761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28762   int jresult ;
28763   int result;
28764
28765   result = (int)Dali::Actor::Property::SIZE;
28766   jresult = (int)result;
28767   return jresult;
28768 }
28769
28770
28771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28772   int jresult ;
28773   int result;
28774
28775   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28776   jresult = (int)result;
28777   return jresult;
28778 }
28779
28780
28781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28782   int jresult ;
28783   int result;
28784
28785   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28786   jresult = (int)result;
28787   return jresult;
28788 }
28789
28790
28791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28792   int jresult ;
28793   int result;
28794
28795   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28796   jresult = (int)result;
28797   return jresult;
28798 }
28799
28800
28801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28802   int jresult ;
28803   int result;
28804
28805   result = (int)Dali::Actor::Property::POSITION;
28806   jresult = (int)result;
28807   return jresult;
28808 }
28809
28810
28811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28812   int jresult ;
28813   int result;
28814
28815   result = (int)Dali::Actor::Property::POSITION_X;
28816   jresult = (int)result;
28817   return jresult;
28818 }
28819
28820
28821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28822   int jresult ;
28823   int result;
28824
28825   result = (int)Dali::Actor::Property::POSITION_Y;
28826   jresult = (int)result;
28827   return jresult;
28828 }
28829
28830
28831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28832   int jresult ;
28833   int result;
28834
28835   result = (int)Dali::Actor::Property::POSITION_Z;
28836   jresult = (int)result;
28837   return jresult;
28838 }
28839
28840
28841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28842   int jresult ;
28843   int result;
28844
28845   result = (int)Dali::Actor::Property::WORLD_POSITION;
28846   jresult = (int)result;
28847   return jresult;
28848 }
28849
28850
28851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28852   int jresult ;
28853   int result;
28854
28855   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28856   jresult = (int)result;
28857   return jresult;
28858 }
28859
28860
28861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28862   int jresult ;
28863   int result;
28864
28865   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28866   jresult = (int)result;
28867   return jresult;
28868 }
28869
28870
28871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28872   int jresult ;
28873   int result;
28874
28875   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28876   jresult = (int)result;
28877   return jresult;
28878 }
28879
28880
28881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28882   int jresult ;
28883   int result;
28884
28885   result = (int)Dali::Actor::Property::ORIENTATION;
28886   jresult = (int)result;
28887   return jresult;
28888 }
28889
28890
28891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28892   int jresult ;
28893   int result;
28894
28895   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28896   jresult = (int)result;
28897   return jresult;
28898 }
28899
28900
28901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
28902   int jresult ;
28903   int result;
28904
28905   result = (int)Dali::Actor::Property::SCALE;
28906   jresult = (int)result;
28907   return jresult;
28908 }
28909
28910
28911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
28912   int jresult ;
28913   int result;
28914
28915   result = (int)Dali::Actor::Property::SCALE_X;
28916   jresult = (int)result;
28917   return jresult;
28918 }
28919
28920
28921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
28922   int jresult ;
28923   int result;
28924
28925   result = (int)Dali::Actor::Property::SCALE_Y;
28926   jresult = (int)result;
28927   return jresult;
28928 }
28929
28930
28931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
28932   int jresult ;
28933   int result;
28934
28935   result = (int)Dali::Actor::Property::SCALE_Z;
28936   jresult = (int)result;
28937   return jresult;
28938 }
28939
28940
28941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
28942   int jresult ;
28943   int result;
28944
28945   result = (int)Dali::Actor::Property::WORLD_SCALE;
28946   jresult = (int)result;
28947   return jresult;
28948 }
28949
28950
28951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
28952   int jresult ;
28953   int result;
28954
28955   result = (int)Dali::Actor::Property::VISIBLE;
28956   jresult = (int)result;
28957   return jresult;
28958 }
28959
28960
28961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
28962   int jresult ;
28963   int result;
28964
28965   result = (int)Dali::Actor::Property::COLOR;
28966   jresult = (int)result;
28967   return jresult;
28968 }
28969
28970
28971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
28972   int jresult ;
28973   int result;
28974
28975   result = (int)Dali::Actor::Property::COLOR_RED;
28976   jresult = (int)result;
28977   return jresult;
28978 }
28979
28980
28981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
28982   int jresult ;
28983   int result;
28984
28985   result = (int)Dali::Actor::Property::COLOR_GREEN;
28986   jresult = (int)result;
28987   return jresult;
28988 }
28989
28990
28991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
28992   int jresult ;
28993   int result;
28994
28995   result = (int)Dali::Actor::Property::COLOR_BLUE;
28996   jresult = (int)result;
28997   return jresult;
28998 }
28999
29000
29001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
29002   int jresult ;
29003   int result;
29004
29005   result = (int)Dali::Actor::Property::COLOR_ALPHA;
29006   jresult = (int)result;
29007   return jresult;
29008 }
29009
29010
29011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
29012   int jresult ;
29013   int result;
29014
29015   result = (int)Dali::Actor::Property::WORLD_COLOR;
29016   jresult = (int)result;
29017   return jresult;
29018 }
29019
29020
29021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
29022   int jresult ;
29023   int result;
29024
29025   result = (int)Dali::Actor::Property::WORLD_MATRIX;
29026   jresult = (int)result;
29027   return jresult;
29028 }
29029
29030
29031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
29032   int jresult ;
29033   int result;
29034
29035   result = (int)Dali::Actor::Property::NAME;
29036   jresult = (int)result;
29037   return jresult;
29038 }
29039
29040
29041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
29042   int jresult ;
29043   int result;
29044
29045   result = (int)Dali::Actor::Property::SENSITIVE;
29046   jresult = (int)result;
29047   return jresult;
29048 }
29049
29050
29051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
29052   int jresult ;
29053   int result;
29054
29055   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
29056   jresult = (int)result;
29057   return jresult;
29058 }
29059
29060
29061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
29062   int jresult ;
29063   int result;
29064
29065   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
29066   jresult = (int)result;
29067   return jresult;
29068 }
29069
29070
29071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
29072   int jresult ;
29073   int result;
29074
29075   result = (int)Dali::Actor::Property::INHERIT_SCALE;
29076   jresult = (int)result;
29077   return jresult;
29078 }
29079
29080
29081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
29082   int jresult ;
29083   int result;
29084
29085   result = (int)Dali::Actor::Property::COLOR_MODE;
29086   jresult = (int)result;
29087   return jresult;
29088 }
29089
29090
29091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
29092   int jresult ;
29093   int result;
29094
29095   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
29096   jresult = (int)result;
29097   return jresult;
29098 }
29099
29100
29101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
29102   int jresult ;
29103   int result;
29104
29105   result = (int)Dali::Actor::Property::DRAW_MODE;
29106   jresult = (int)result;
29107   return jresult;
29108 }
29109
29110
29111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
29112   int jresult ;
29113   int result;
29114
29115   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
29116   jresult = (int)result;
29117   return jresult;
29118 }
29119
29120
29121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
29122   int jresult ;
29123   int result;
29124
29125   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
29126   jresult = (int)result;
29127   return jresult;
29128 }
29129
29130
29131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
29132   int jresult ;
29133   int result;
29134
29135   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
29136   jresult = (int)result;
29137   return jresult;
29138 }
29139
29140
29141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
29142   int jresult ;
29143   int result;
29144
29145   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
29146   jresult = (int)result;
29147   return jresult;
29148 }
29149
29150
29151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
29152   int jresult ;
29153   int result;
29154
29155   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
29156   jresult = (int)result;
29157   return jresult;
29158 }
29159
29160
29161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
29162   int jresult ;
29163   int result;
29164
29165   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
29166   jresult = (int)result;
29167   return jresult;
29168 }
29169
29170
29171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
29172   int jresult ;
29173   int result;
29174
29175   result = (int)Dali::Actor::Property::PADDING;
29176   jresult = (int)result;
29177   return jresult;
29178 }
29179
29180
29181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
29182   int jresult ;
29183   int result;
29184
29185   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
29186   jresult = (int)result;
29187   return jresult;
29188 }
29189
29190
29191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
29192   int jresult ;
29193   int result;
29194
29195   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
29196   jresult = (int)result;
29197   return jresult;
29198 }
29199
29200
29201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
29202   int jresult ;
29203   int result;
29204
29205   result = (int)Dali::Actor::Property::INHERIT_POSITION;
29206   jresult = (int)result;
29207   return jresult;
29208 }
29209
29210
29211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
29212   int jresult ;
29213   int result;
29214
29215   result = (int)Dali::Actor::Property::CLIPPING_MODE;
29216   jresult = (int)result;
29217   return jresult;
29218 }
29219
29220
29221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
29222   void * jresult ;
29223   Dali::Actor::Property *result = 0 ;
29224
29225   {
29226     try {
29227       result = (Dali::Actor::Property *)new Dali::Actor::Property();
29228     } catch (std::out_of_range& e) {
29229       {
29230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29231       };
29232     } catch (std::exception& e) {
29233       {
29234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29235       };
29236     } catch (...) {
29237       {
29238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29239       };
29240     }
29241   }
29242   jresult = (void *)result;
29243   return jresult;
29244 }
29245
29246
29247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
29248   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
29249
29250   arg1 = (Dali::Actor::Property *)jarg1;
29251   {
29252     try {
29253       delete arg1;
29254     } catch (std::out_of_range& e) {
29255       {
29256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29257       };
29258     } catch (std::exception& e) {
29259       {
29260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29261       };
29262     } catch (...) {
29263       {
29264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29265       };
29266     }
29267   }
29268 }
29269
29270
29271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
29272   void * jresult ;
29273   Dali::Actor *result = 0 ;
29274
29275   {
29276     try {
29277       result = (Dali::Actor *)new Dali::Actor();
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 void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29298   void * jresult ;
29299   Dali::Actor result;
29300
29301   {
29302     try {
29303       result = Dali::Actor::New();
29304     } catch (std::out_of_range& e) {
29305       {
29306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29307       };
29308     } catch (std::exception& e) {
29309       {
29310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29311       };
29312     } catch (...) {
29313       {
29314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29315       };
29316     }
29317   }
29318   jresult = new Dali::Actor((const Dali::Actor &)result);
29319   return jresult;
29320 }
29321
29322
29323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29324   void * jresult ;
29325   Dali::BaseHandle arg1 ;
29326   Dali::BaseHandle *argp1 ;
29327   Dali::Actor result;
29328
29329   argp1 = (Dali::BaseHandle *)jarg1;
29330   if (!argp1) {
29331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29332     return 0;
29333   }
29334   arg1 = *argp1;
29335   {
29336     try {
29337       result = Dali::Actor::DownCast(arg1);
29338     } catch (std::out_of_range& e) {
29339       {
29340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29341       };
29342     } catch (std::exception& e) {
29343       {
29344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29345       };
29346     } catch (...) {
29347       {
29348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29349       };
29350     }
29351   }
29352   jresult = new Dali::Actor((const Dali::Actor &)result);
29353   return jresult;
29354 }
29355
29356
29357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29358   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29359
29360   arg1 = (Dali::Actor *)jarg1;
29361   {
29362     try {
29363       delete arg1;
29364     } catch (std::out_of_range& e) {
29365       {
29366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29367       };
29368     } catch (std::exception& e) {
29369       {
29370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29371       };
29372     } catch (...) {
29373       {
29374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29375       };
29376     }
29377   }
29378 }
29379
29380
29381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29382   void * jresult ;
29383   Dali::Actor *arg1 = 0 ;
29384   Dali::Actor *result = 0 ;
29385
29386   arg1 = (Dali::Actor *)jarg1;
29387   if (!arg1) {
29388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29389     return 0;
29390   }
29391   {
29392     try {
29393       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29394     } catch (std::out_of_range& e) {
29395       {
29396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29397       };
29398     } catch (std::exception& e) {
29399       {
29400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29401       };
29402     } catch (...) {
29403       {
29404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29405       };
29406     }
29407   }
29408   jresult = (void *)result;
29409   return jresult;
29410 }
29411
29412
29413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29414   void * jresult ;
29415   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29416   Dali::Actor *arg2 = 0 ;
29417   Dali::Actor *result = 0 ;
29418
29419   arg1 = (Dali::Actor *)jarg1;
29420   arg2 = (Dali::Actor *)jarg2;
29421   if (!arg2) {
29422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29423     return 0;
29424   }
29425   {
29426     try {
29427       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29428     } catch (std::out_of_range& e) {
29429       {
29430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29431       };
29432     } catch (std::exception& e) {
29433       {
29434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29435       };
29436     } catch (...) {
29437       {
29438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29439       };
29440     }
29441   }
29442   jresult = (void *)result;
29443   return jresult;
29444 }
29445
29446
29447 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29448   char * jresult ;
29449   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29450   std::string *result = 0 ;
29451
29452   arg1 = (Dali::Actor *)jarg1;
29453   {
29454     try {
29455       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29456     } catch (std::out_of_range& e) {
29457       {
29458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29459       };
29460     } catch (std::exception& e) {
29461       {
29462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29463       };
29464     } catch (...) {
29465       {
29466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29467       };
29468     }
29469   }
29470   jresult = SWIG_csharp_string_callback(result->c_str());
29471   return jresult;
29472 }
29473
29474
29475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29476   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29477   std::string *arg2 = 0 ;
29478
29479   arg1 = (Dali::Actor *)jarg1;
29480   if (!jarg2) {
29481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29482     return ;
29483   }
29484   std::string arg2_str(jarg2);
29485   arg2 = &arg2_str;
29486   {
29487     try {
29488       (arg1)->SetName((std::string const &)*arg2);
29489     } catch (std::out_of_range& e) {
29490       {
29491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29492       };
29493     } catch (std::exception& e) {
29494       {
29495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29496       };
29497     } catch (...) {
29498       {
29499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29500       };
29501     }
29502   }
29503
29504   //argout typemap for const std::string&
29505
29506 }
29507
29508
29509 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29510   unsigned int jresult ;
29511   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29512   unsigned int result;
29513
29514   arg1 = (Dali::Actor *)jarg1;
29515   {
29516     try {
29517       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29518     } catch (std::out_of_range& e) {
29519       {
29520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29521       };
29522     } catch (std::exception& e) {
29523       {
29524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29525       };
29526     } catch (...) {
29527       {
29528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29529       };
29530     }
29531   }
29532   jresult = result;
29533   return jresult;
29534 }
29535
29536
29537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29538   unsigned int jresult ;
29539   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29540   bool result;
29541
29542   arg1 = (Dali::Actor *)jarg1;
29543   {
29544     try {
29545       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29546     } catch (std::out_of_range& e) {
29547       {
29548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29549       };
29550     } catch (std::exception& e) {
29551       {
29552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29553       };
29554     } catch (...) {
29555       {
29556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29557       };
29558     }
29559   }
29560   jresult = result;
29561   return jresult;
29562 }
29563
29564
29565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29566   unsigned int jresult ;
29567   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29568   bool result;
29569
29570   arg1 = (Dali::Actor *)jarg1;
29571   {
29572     try {
29573       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29574     } catch (std::out_of_range& e) {
29575       {
29576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29577       };
29578     } catch (std::exception& e) {
29579       {
29580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29581       };
29582     } catch (...) {
29583       {
29584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29585       };
29586     }
29587   }
29588   jresult = result;
29589   return jresult;
29590 }
29591
29592
29593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29594   unsigned int jresult ;
29595   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29596   bool result;
29597
29598   arg1 = (Dali::Actor *)jarg1;
29599   {
29600     try {
29601       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29602     } catch (std::out_of_range& e) {
29603       {
29604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29605       };
29606     } catch (std::exception& e) {
29607       {
29608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29609       };
29610     } catch (...) {
29611       {
29612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29613       };
29614     }
29615   }
29616   jresult = result;
29617   return jresult;
29618 }
29619
29620
29621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29622   void * jresult ;
29623   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29624   Dali::Layer result;
29625
29626   arg1 = (Dali::Actor *)jarg1;
29627   {
29628     try {
29629       result = (arg1)->GetLayer();
29630     } catch (std::out_of_range& e) {
29631       {
29632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29633       };
29634     } catch (std::exception& e) {
29635       {
29636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29637       };
29638     } catch (...) {
29639       {
29640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29641       };
29642     }
29643   }
29644   jresult = new Dali::Layer((const Dali::Layer &)result);
29645   return jresult;
29646 }
29647
29648
29649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29650   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29651   Dali::Actor arg2 ;
29652   Dali::Actor *argp2 ;
29653
29654   arg1 = (Dali::Actor *)jarg1;
29655   argp2 = (Dali::Actor *)jarg2;
29656   if (!argp2) {
29657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29658     return ;
29659   }
29660   arg2 = *argp2;
29661   {
29662     try {
29663       (arg1)->Add(arg2);
29664     } catch (std::out_of_range& e) {
29665       {
29666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29667       };
29668     } catch (std::exception& e) {
29669       {
29670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29671       };
29672     } catch (...) {
29673       {
29674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29675       };
29676     }
29677   }
29678 }
29679
29680
29681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29682   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29683   Dali::Actor arg2 ;
29684   Dali::Actor *argp2 ;
29685
29686   arg1 = (Dali::Actor *)jarg1;
29687   argp2 = (Dali::Actor *)jarg2;
29688   if (!argp2) {
29689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29690     return ;
29691   }
29692   arg2 = *argp2;
29693   {
29694     try {
29695       (arg1)->Remove(arg2);
29696     } catch (std::out_of_range& e) {
29697       {
29698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29699       };
29700     } catch (std::exception& e) {
29701       {
29702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29703       };
29704     } catch (...) {
29705       {
29706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29707       };
29708     }
29709   }
29710 }
29711
29712
29713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29714   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29715
29716   arg1 = (Dali::Actor *)jarg1;
29717   {
29718     try {
29719       (arg1)->Unparent();
29720     } catch (std::out_of_range& e) {
29721       {
29722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29723       };
29724     } catch (std::exception& e) {
29725       {
29726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29727       };
29728     } catch (...) {
29729       {
29730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29731       };
29732     }
29733   }
29734 }
29735
29736
29737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29738   unsigned int jresult ;
29739   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29740   unsigned int result;
29741
29742   arg1 = (Dali::Actor *)jarg1;
29743   {
29744     try {
29745       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29746     } catch (std::out_of_range& e) {
29747       {
29748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29749       };
29750     } catch (std::exception& e) {
29751       {
29752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29753       };
29754     } catch (...) {
29755       {
29756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29757       };
29758     }
29759   }
29760   jresult = result;
29761   return jresult;
29762 }
29763
29764
29765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29766   void * jresult ;
29767   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29768   unsigned int arg2 ;
29769   Dali::Actor result;
29770
29771   arg1 = (Dali::Actor *)jarg1;
29772   arg2 = (unsigned int)jarg2;
29773   {
29774     try {
29775       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29776     } catch (std::out_of_range& e) {
29777       {
29778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29779       };
29780     } catch (std::exception& e) {
29781       {
29782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29783       };
29784     } catch (...) {
29785       {
29786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29787       };
29788     }
29789   }
29790   jresult = new Dali::Actor((const Dali::Actor &)result);
29791   return jresult;
29792 }
29793
29794
29795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29796   void * jresult ;
29797   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29798   std::string *arg2 = 0 ;
29799   Dali::Actor result;
29800
29801   arg1 = (Dali::Actor *)jarg1;
29802   if (!jarg2) {
29803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29804     return 0;
29805   }
29806   std::string arg2_str(jarg2);
29807   arg2 = &arg2_str;
29808   {
29809     try {
29810       result = (arg1)->FindChildByName((std::string const &)*arg2);
29811     } catch (std::out_of_range& e) {
29812       {
29813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29814       };
29815     } catch (std::exception& e) {
29816       {
29817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29818       };
29819     } catch (...) {
29820       {
29821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29822       };
29823     }
29824   }
29825   jresult = new Dali::Actor((const Dali::Actor &)result);
29826
29827   //argout typemap for const std::string&
29828
29829   return jresult;
29830 }
29831
29832
29833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29834   void * jresult ;
29835   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29836   unsigned int arg2 ;
29837   Dali::Actor result;
29838
29839   arg1 = (Dali::Actor *)jarg1;
29840   arg2 = (unsigned int)jarg2;
29841   {
29842     try {
29843       result = (arg1)->FindChildById(arg2);
29844     } catch (std::out_of_range& e) {
29845       {
29846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29847       };
29848     } catch (std::exception& e) {
29849       {
29850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29851       };
29852     } catch (...) {
29853       {
29854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29855       };
29856     }
29857   }
29858   jresult = new Dali::Actor((const Dali::Actor &)result);
29859   return jresult;
29860 }
29861
29862
29863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29864   void * jresult ;
29865   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29866   Dali::Actor result;
29867
29868   arg1 = (Dali::Actor *)jarg1;
29869   {
29870     try {
29871       result = ((Dali::Actor const *)arg1)->GetParent();
29872     } catch (std::out_of_range& e) {
29873       {
29874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29875       };
29876     } catch (std::exception& e) {
29877       {
29878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29879       };
29880     } catch (...) {
29881       {
29882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29883       };
29884     }
29885   }
29886   jresult = new Dali::Actor((const Dali::Actor &)result);
29887   return jresult;
29888 }
29889
29890
29891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29892   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29893   Dali::Vector3 *arg2 = 0 ;
29894
29895   arg1 = (Dali::Actor *)jarg1;
29896   arg2 = (Dali::Vector3 *)jarg2;
29897   if (!arg2) {
29898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29899     return ;
29900   }
29901   {
29902     try {
29903       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
29904     } catch (std::out_of_range& e) {
29905       {
29906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29907       };
29908     } catch (std::exception& e) {
29909       {
29910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29911       };
29912     } catch (...) {
29913       {
29914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29915       };
29916     }
29917   }
29918 }
29919
29920
29921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
29922   void * jresult ;
29923   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29924   Dali::Vector3 result;
29925
29926   arg1 = (Dali::Actor *)jarg1;
29927   {
29928     try {
29929       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29930     } catch (std::out_of_range& e) {
29931       {
29932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29933       };
29934     } catch (std::exception& e) {
29935       {
29936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29937       };
29938     } catch (...) {
29939       {
29940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29941       };
29942     }
29943   }
29944   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29945   return jresult;
29946 }
29947
29948
29949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29950   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29951   Dali::Vector3 *arg2 = 0 ;
29952
29953   arg1 = (Dali::Actor *)jarg1;
29954   arg2 = (Dali::Vector3 *)jarg2;
29955   if (!arg2) {
29956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29957     return ;
29958   }
29959   {
29960     try {
29961       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29962     } catch (std::out_of_range& e) {
29963       {
29964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29965       };
29966     } catch (std::exception& e) {
29967       {
29968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29969       };
29970     } catch (...) {
29971       {
29972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29973       };
29974     }
29975   }
29976 }
29977
29978
29979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
29980   void * jresult ;
29981   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29982   Dali::Vector3 result;
29983
29984   arg1 = (Dali::Actor *)jarg1;
29985   {
29986     try {
29987       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
29988     } catch (std::out_of_range& e) {
29989       {
29990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29991       };
29992     } catch (std::exception& e) {
29993       {
29994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29995       };
29996     } catch (...) {
29997       {
29998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29999       };
30000     }
30001   }
30002   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30003   return jresult;
30004 }
30005
30006
30007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30008   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30009   float arg2 ;
30010   float arg3 ;
30011
30012   arg1 = (Dali::Actor *)jarg1;
30013   arg2 = (float)jarg2;
30014   arg3 = (float)jarg3;
30015   {
30016     try {
30017       (arg1)->SetSize(arg2,arg3);
30018     } catch (std::out_of_range& e) {
30019       {
30020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30021       };
30022     } catch (std::exception& e) {
30023       {
30024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30025       };
30026     } catch (...) {
30027       {
30028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30029       };
30030     }
30031   }
30032 }
30033
30034
30035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30036   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30037   float arg2 ;
30038   float arg3 ;
30039   float arg4 ;
30040
30041   arg1 = (Dali::Actor *)jarg1;
30042   arg2 = (float)jarg2;
30043   arg3 = (float)jarg3;
30044   arg4 = (float)jarg4;
30045   {
30046     try {
30047       (arg1)->SetSize(arg2,arg3,arg4);
30048     } catch (std::out_of_range& e) {
30049       {
30050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30051       };
30052     } catch (std::exception& e) {
30053       {
30054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30055       };
30056     } catch (...) {
30057       {
30058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30059       };
30060     }
30061   }
30062 }
30063
30064
30065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
30066   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30067   Dali::Vector2 *arg2 = 0 ;
30068
30069   arg1 = (Dali::Actor *)jarg1;
30070   arg2 = (Dali::Vector2 *)jarg2;
30071   if (!arg2) {
30072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
30073     return ;
30074   }
30075   {
30076     try {
30077       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
30078     } catch (std::out_of_range& e) {
30079       {
30080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30081       };
30082     } catch (std::exception& e) {
30083       {
30084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30085       };
30086     } catch (...) {
30087       {
30088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30089       };
30090     }
30091   }
30092 }
30093
30094
30095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
30096   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30097   Dali::Vector3 *arg2 = 0 ;
30098
30099   arg1 = (Dali::Actor *)jarg1;
30100   arg2 = (Dali::Vector3 *)jarg2;
30101   if (!arg2) {
30102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30103     return ;
30104   }
30105   {
30106     try {
30107       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
30108     } catch (std::out_of_range& e) {
30109       {
30110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30111       };
30112     } catch (std::exception& e) {
30113       {
30114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30115       };
30116     } catch (...) {
30117       {
30118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30119       };
30120     }
30121   }
30122 }
30123
30124
30125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
30126   void * jresult ;
30127   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30128   Dali::Vector3 result;
30129
30130   arg1 = (Dali::Actor *)jarg1;
30131   {
30132     try {
30133       result = ((Dali::Actor const *)arg1)->GetTargetSize();
30134     } catch (std::out_of_range& e) {
30135       {
30136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30137       };
30138     } catch (std::exception& e) {
30139       {
30140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30141       };
30142     } catch (...) {
30143       {
30144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30145       };
30146     }
30147   }
30148   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30149   return jresult;
30150 }
30151
30152
30153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
30154   void * jresult ;
30155   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30156   Dali::Vector3 result;
30157
30158   arg1 = (Dali::Actor *)jarg1;
30159   {
30160     try {
30161       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
30162     } catch (std::out_of_range& e) {
30163       {
30164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30165       };
30166     } catch (std::exception& e) {
30167       {
30168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30169       };
30170     } catch (...) {
30171       {
30172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30173       };
30174     }
30175   }
30176   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30177   return jresult;
30178 }
30179
30180
30181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
30182   void * jresult ;
30183   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30184   Dali::Vector3 result;
30185
30186   arg1 = (Dali::Actor *)jarg1;
30187   {
30188     try {
30189       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
30190     } catch (std::out_of_range& e) {
30191       {
30192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30193       };
30194     } catch (std::exception& e) {
30195       {
30196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30197       };
30198     } catch (...) {
30199       {
30200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30201       };
30202     }
30203   }
30204   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30205   return jresult;
30206 }
30207
30208
30209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30210   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30211   float arg2 ;
30212   float arg3 ;
30213
30214   arg1 = (Dali::Actor *)jarg1;
30215   arg2 = (float)jarg2;
30216   arg3 = (float)jarg3;
30217   {
30218     try {
30219       (arg1)->SetPosition(arg2,arg3);
30220     } catch (std::out_of_range& e) {
30221       {
30222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30223       };
30224     } catch (std::exception& e) {
30225       {
30226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30227       };
30228     } catch (...) {
30229       {
30230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30231       };
30232     }
30233   }
30234 }
30235
30236
30237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30238   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30239   float arg2 ;
30240   float arg3 ;
30241   float arg4 ;
30242
30243   arg1 = (Dali::Actor *)jarg1;
30244   arg2 = (float)jarg2;
30245   arg3 = (float)jarg3;
30246   arg4 = (float)jarg4;
30247   {
30248     try {
30249       (arg1)->SetPosition(arg2,arg3,arg4);
30250     } catch (std::out_of_range& e) {
30251       {
30252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30253       };
30254     } catch (std::exception& e) {
30255       {
30256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30257       };
30258     } catch (...) {
30259       {
30260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30261       };
30262     }
30263   }
30264 }
30265
30266
30267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
30268   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30269   Dali::Vector3 *arg2 = 0 ;
30270
30271   arg1 = (Dali::Actor *)jarg1;
30272   arg2 = (Dali::Vector3 *)jarg2;
30273   if (!arg2) {
30274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30275     return ;
30276   }
30277   {
30278     try {
30279       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30280     } catch (std::out_of_range& e) {
30281       {
30282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30283       };
30284     } catch (std::exception& e) {
30285       {
30286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30287       };
30288     } catch (...) {
30289       {
30290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30291       };
30292     }
30293   }
30294 }
30295
30296
30297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30298   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30299   float arg2 ;
30300
30301   arg1 = (Dali::Actor *)jarg1;
30302   arg2 = (float)jarg2;
30303   {
30304     try {
30305       (arg1)->SetX(arg2);
30306     } catch (std::out_of_range& e) {
30307       {
30308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30309       };
30310     } catch (std::exception& e) {
30311       {
30312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30313       };
30314     } catch (...) {
30315       {
30316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30317       };
30318     }
30319   }
30320 }
30321
30322
30323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30324   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30325   float arg2 ;
30326
30327   arg1 = (Dali::Actor *)jarg1;
30328   arg2 = (float)jarg2;
30329   {
30330     try {
30331       (arg1)->SetY(arg2);
30332     } catch (std::out_of_range& e) {
30333       {
30334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30335       };
30336     } catch (std::exception& e) {
30337       {
30338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30339       };
30340     } catch (...) {
30341       {
30342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30343       };
30344     }
30345   }
30346 }
30347
30348
30349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30350   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30351   float arg2 ;
30352
30353   arg1 = (Dali::Actor *)jarg1;
30354   arg2 = (float)jarg2;
30355   {
30356     try {
30357       (arg1)->SetZ(arg2);
30358     } catch (std::out_of_range& e) {
30359       {
30360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30361       };
30362     } catch (std::exception& e) {
30363       {
30364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30365       };
30366     } catch (...) {
30367       {
30368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30369       };
30370     }
30371   }
30372 }
30373
30374
30375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30376   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30377   Dali::Vector3 *arg2 = 0 ;
30378
30379   arg1 = (Dali::Actor *)jarg1;
30380   arg2 = (Dali::Vector3 *)jarg2;
30381   if (!arg2) {
30382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30383     return ;
30384   }
30385   {
30386     try {
30387       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30388     } catch (std::out_of_range& e) {
30389       {
30390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30391       };
30392     } catch (std::exception& e) {
30393       {
30394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30395       };
30396     } catch (...) {
30397       {
30398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30399       };
30400     }
30401   }
30402 }
30403
30404
30405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30406   void * jresult ;
30407   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30408   Dali::Vector3 result;
30409
30410   arg1 = (Dali::Actor *)jarg1;
30411   {
30412     try {
30413       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30414     } catch (std::out_of_range& e) {
30415       {
30416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30417       };
30418     } catch (std::exception& e) {
30419       {
30420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30421       };
30422     } catch (...) {
30423       {
30424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30425       };
30426     }
30427   }
30428   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30429   return jresult;
30430 }
30431
30432
30433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30434   void * jresult ;
30435   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30436   Dali::Vector3 result;
30437
30438   arg1 = (Dali::Actor *)jarg1;
30439   {
30440     try {
30441       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30442     } catch (std::out_of_range& e) {
30443       {
30444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30445       };
30446     } catch (std::exception& e) {
30447       {
30448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30449       };
30450     } catch (...) {
30451       {
30452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30453       };
30454     }
30455   }
30456   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30457   return jresult;
30458 }
30459
30460
30461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30462   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30463   bool arg2 ;
30464
30465   arg1 = (Dali::Actor *)jarg1;
30466   arg2 = jarg2 ? true : false;
30467   {
30468     try {
30469       (arg1)->SetInheritPosition(arg2);
30470     } catch (std::out_of_range& e) {
30471       {
30472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30473       };
30474     } catch (std::exception& e) {
30475       {
30476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30477       };
30478     } catch (...) {
30479       {
30480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30481       };
30482     }
30483   }
30484 }
30485
30486
30487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30488   int jresult ;
30489   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30490   Dali::PositionInheritanceMode result;
30491
30492   arg1 = (Dali::Actor *)jarg1;
30493   {
30494     try {
30495       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30496     } catch (std::out_of_range& e) {
30497       {
30498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30499       };
30500     } catch (std::exception& e) {
30501       {
30502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30503       };
30504     } catch (...) {
30505       {
30506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30507       };
30508     }
30509   }
30510   jresult = (int)result;
30511   return jresult;
30512 }
30513
30514
30515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30516   unsigned int jresult ;
30517   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30518   bool result;
30519
30520   arg1 = (Dali::Actor *)jarg1;
30521   {
30522     try {
30523       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30524     } catch (std::out_of_range& e) {
30525       {
30526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30527       };
30528     } catch (std::exception& e) {
30529       {
30530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30531       };
30532     } catch (...) {
30533       {
30534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30535       };
30536     }
30537   }
30538   jresult = result;
30539   return jresult;
30540 }
30541
30542
30543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30544   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30545   Dali::Degree *arg2 = 0 ;
30546   Dali::Vector3 *arg3 = 0 ;
30547
30548   arg1 = (Dali::Actor *)jarg1;
30549   arg2 = (Dali::Degree *)jarg2;
30550   if (!arg2) {
30551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30552     return ;
30553   }
30554   arg3 = (Dali::Vector3 *)jarg3;
30555   if (!arg3) {
30556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30557     return ;
30558   }
30559   {
30560     try {
30561       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30562     } catch (std::out_of_range& e) {
30563       {
30564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30565       };
30566     } catch (std::exception& e) {
30567       {
30568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30569       };
30570     } catch (...) {
30571       {
30572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30573       };
30574     }
30575   }
30576 }
30577
30578
30579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30580   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30581   Dali::Radian *arg2 = 0 ;
30582   Dali::Vector3 *arg3 = 0 ;
30583
30584   arg1 = (Dali::Actor *)jarg1;
30585   arg2 = (Dali::Radian *)jarg2;
30586   if (!arg2) {
30587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30588     return ;
30589   }
30590   arg3 = (Dali::Vector3 *)jarg3;
30591   if (!arg3) {
30592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30593     return ;
30594   }
30595   {
30596     try {
30597       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30598     } catch (std::out_of_range& e) {
30599       {
30600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30601       };
30602     } catch (std::exception& e) {
30603       {
30604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30605       };
30606     } catch (...) {
30607       {
30608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30609       };
30610     }
30611   }
30612 }
30613
30614
30615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30616   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30617   Dali::Quaternion *arg2 = 0 ;
30618
30619   arg1 = (Dali::Actor *)jarg1;
30620   arg2 = (Dali::Quaternion *)jarg2;
30621   if (!arg2) {
30622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30623     return ;
30624   }
30625   {
30626     try {
30627       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30628     } catch (std::out_of_range& e) {
30629       {
30630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30631       };
30632     } catch (std::exception& e) {
30633       {
30634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30635       };
30636     } catch (...) {
30637       {
30638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30639       };
30640     }
30641   }
30642 }
30643
30644
30645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30646   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30647   Dali::Degree *arg2 = 0 ;
30648   Dali::Vector3 *arg3 = 0 ;
30649
30650   arg1 = (Dali::Actor *)jarg1;
30651   arg2 = (Dali::Degree *)jarg2;
30652   if (!arg2) {
30653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30654     return ;
30655   }
30656   arg3 = (Dali::Vector3 *)jarg3;
30657   if (!arg3) {
30658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30659     return ;
30660   }
30661   {
30662     try {
30663       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30664     } catch (std::out_of_range& e) {
30665       {
30666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30667       };
30668     } catch (std::exception& e) {
30669       {
30670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30671       };
30672     } catch (...) {
30673       {
30674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30675       };
30676     }
30677   }
30678 }
30679
30680
30681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30682   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30683   Dali::Radian *arg2 = 0 ;
30684   Dali::Vector3 *arg3 = 0 ;
30685
30686   arg1 = (Dali::Actor *)jarg1;
30687   arg2 = (Dali::Radian *)jarg2;
30688   if (!arg2) {
30689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30690     return ;
30691   }
30692   arg3 = (Dali::Vector3 *)jarg3;
30693   if (!arg3) {
30694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30695     return ;
30696   }
30697   {
30698     try {
30699       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30700     } catch (std::out_of_range& e) {
30701       {
30702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30703       };
30704     } catch (std::exception& e) {
30705       {
30706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30707       };
30708     } catch (...) {
30709       {
30710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30711       };
30712     }
30713   }
30714 }
30715
30716
30717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30718   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30719   Dali::Quaternion *arg2 = 0 ;
30720
30721   arg1 = (Dali::Actor *)jarg1;
30722   arg2 = (Dali::Quaternion *)jarg2;
30723   if (!arg2) {
30724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30725     return ;
30726   }
30727   {
30728     try {
30729       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30730     } catch (std::out_of_range& e) {
30731       {
30732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30733       };
30734     } catch (std::exception& e) {
30735       {
30736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30737       };
30738     } catch (...) {
30739       {
30740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30741       };
30742     }
30743   }
30744 }
30745
30746
30747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30748   void * jresult ;
30749   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30750   Dali::Quaternion result;
30751
30752   arg1 = (Dali::Actor *)jarg1;
30753   {
30754     try {
30755       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30756     } catch (std::out_of_range& e) {
30757       {
30758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30759       };
30760     } catch (std::exception& e) {
30761       {
30762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30763       };
30764     } catch (...) {
30765       {
30766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30767       };
30768     }
30769   }
30770   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30771   return jresult;
30772 }
30773
30774
30775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30776   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30777   bool arg2 ;
30778
30779   arg1 = (Dali::Actor *)jarg1;
30780   arg2 = jarg2 ? true : false;
30781   {
30782     try {
30783       (arg1)->SetInheritOrientation(arg2);
30784     } catch (std::out_of_range& e) {
30785       {
30786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30787       };
30788     } catch (std::exception& e) {
30789       {
30790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30791       };
30792     } catch (...) {
30793       {
30794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30795       };
30796     }
30797   }
30798 }
30799
30800
30801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30802   unsigned int jresult ;
30803   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30804   bool result;
30805
30806   arg1 = (Dali::Actor *)jarg1;
30807   {
30808     try {
30809       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30810     } catch (std::out_of_range& e) {
30811       {
30812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30813       };
30814     } catch (std::exception& e) {
30815       {
30816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30817       };
30818     } catch (...) {
30819       {
30820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30821       };
30822     }
30823   }
30824   jresult = result;
30825   return jresult;
30826 }
30827
30828
30829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30830   void * jresult ;
30831   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30832   Dali::Quaternion result;
30833
30834   arg1 = (Dali::Actor *)jarg1;
30835   {
30836     try {
30837       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30838     } catch (std::out_of_range& e) {
30839       {
30840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30841       };
30842     } catch (std::exception& e) {
30843       {
30844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30845       };
30846     } catch (...) {
30847       {
30848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30849       };
30850     }
30851   }
30852   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30853   return jresult;
30854 }
30855
30856
30857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30859   float arg2 ;
30860
30861   arg1 = (Dali::Actor *)jarg1;
30862   arg2 = (float)jarg2;
30863   {
30864     try {
30865       (arg1)->SetScale(arg2);
30866     } catch (std::out_of_range& e) {
30867       {
30868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30869       };
30870     } catch (std::exception& e) {
30871       {
30872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30873       };
30874     } catch (...) {
30875       {
30876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30877       };
30878     }
30879   }
30880 }
30881
30882
30883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30884   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30885   float arg2 ;
30886   float arg3 ;
30887   float arg4 ;
30888
30889   arg1 = (Dali::Actor *)jarg1;
30890   arg2 = (float)jarg2;
30891   arg3 = (float)jarg3;
30892   arg4 = (float)jarg4;
30893   {
30894     try {
30895       (arg1)->SetScale(arg2,arg3,arg4);
30896     } catch (std::out_of_range& e) {
30897       {
30898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30899       };
30900     } catch (std::exception& e) {
30901       {
30902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30903       };
30904     } catch (...) {
30905       {
30906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30907       };
30908     }
30909   }
30910 }
30911
30912
30913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30914   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30915   Dali::Vector3 *arg2 = 0 ;
30916
30917   arg1 = (Dali::Actor *)jarg1;
30918   arg2 = (Dali::Vector3 *)jarg2;
30919   if (!arg2) {
30920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30921     return ;
30922   }
30923   {
30924     try {
30925       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30926     } catch (std::out_of_range& e) {
30927       {
30928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30929       };
30930     } catch (std::exception& e) {
30931       {
30932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30933       };
30934     } catch (...) {
30935       {
30936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30937       };
30938     }
30939   }
30940 }
30941
30942
30943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
30944   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30945   Dali::Vector3 *arg2 = 0 ;
30946
30947   arg1 = (Dali::Actor *)jarg1;
30948   arg2 = (Dali::Vector3 *)jarg2;
30949   if (!arg2) {
30950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30951     return ;
30952   }
30953   {
30954     try {
30955       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30956     } catch (std::out_of_range& e) {
30957       {
30958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30959       };
30960     } catch (std::exception& e) {
30961       {
30962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30963       };
30964     } catch (...) {
30965       {
30966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30967       };
30968     }
30969   }
30970 }
30971
30972
30973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
30974   void * jresult ;
30975   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30976   Dali::Vector3 result;
30977
30978   arg1 = (Dali::Actor *)jarg1;
30979   {
30980     try {
30981       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
30982     } catch (std::out_of_range& e) {
30983       {
30984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30985       };
30986     } catch (std::exception& e) {
30987       {
30988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30989       };
30990     } catch (...) {
30991       {
30992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30993       };
30994     }
30995   }
30996   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30997   return jresult;
30998 }
30999
31000
31001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
31002   void * jresult ;
31003   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31004   Dali::Vector3 result;
31005
31006   arg1 = (Dali::Actor *)jarg1;
31007   {
31008     try {
31009       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
31010     } catch (std::out_of_range& e) {
31011       {
31012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31013       };
31014     } catch (std::exception& e) {
31015       {
31016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31017       };
31018     } catch (...) {
31019       {
31020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31021       };
31022     }
31023   }
31024   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31025   return jresult;
31026 }
31027
31028
31029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
31030   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31031   bool arg2 ;
31032
31033   arg1 = (Dali::Actor *)jarg1;
31034   arg2 = jarg2 ? true : false;
31035   {
31036     try {
31037       (arg1)->SetInheritScale(arg2);
31038     } catch (std::out_of_range& e) {
31039       {
31040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31041       };
31042     } catch (std::exception& e) {
31043       {
31044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31045       };
31046     } catch (...) {
31047       {
31048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31049       };
31050     }
31051   }
31052 }
31053
31054
31055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
31056   unsigned int jresult ;
31057   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31058   bool result;
31059
31060   arg1 = (Dali::Actor *)jarg1;
31061   {
31062     try {
31063       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
31064     } catch (std::out_of_range& e) {
31065       {
31066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31067       };
31068     } catch (std::exception& e) {
31069       {
31070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31071       };
31072     } catch (...) {
31073       {
31074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31075       };
31076     }
31077   }
31078   jresult = result;
31079   return jresult;
31080 }
31081
31082
31083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
31084   void * jresult ;
31085   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31086   Dali::Matrix result;
31087
31088   arg1 = (Dali::Actor *)jarg1;
31089   {
31090     try {
31091       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
31092     } catch (std::out_of_range& e) {
31093       {
31094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31095       };
31096     } catch (std::exception& e) {
31097       {
31098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31099       };
31100     } catch (...) {
31101       {
31102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31103       };
31104     }
31105   }
31106   jresult = new Dali::Matrix((const Dali::Matrix &)result);
31107   return jresult;
31108 }
31109
31110
31111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
31112   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31113   bool arg2 ;
31114
31115   arg1 = (Dali::Actor *)jarg1;
31116   arg2 = jarg2 ? true : false;
31117   {
31118     try {
31119       (arg1)->SetVisible(arg2);
31120     } catch (std::out_of_range& e) {
31121       {
31122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31123       };
31124     } catch (std::exception& e) {
31125       {
31126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31127       };
31128     } catch (...) {
31129       {
31130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31131       };
31132     }
31133   }
31134 }
31135
31136
31137 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
31138   unsigned int jresult ;
31139   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31140   bool result;
31141
31142   arg1 = (Dali::Actor *)jarg1;
31143   {
31144     try {
31145       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
31146     } catch (std::out_of_range& e) {
31147       {
31148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31149       };
31150     } catch (std::exception& e) {
31151       {
31152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31153       };
31154     } catch (...) {
31155       {
31156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31157       };
31158     }
31159   }
31160   jresult = result;
31161   return jresult;
31162 }
31163
31164
31165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
31166   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31167   float arg2 ;
31168
31169   arg1 = (Dali::Actor *)jarg1;
31170   arg2 = (float)jarg2;
31171   {
31172     try {
31173       (arg1)->SetOpacity(arg2);
31174     } catch (std::out_of_range& e) {
31175       {
31176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31177       };
31178     } catch (std::exception& e) {
31179       {
31180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31181       };
31182     } catch (...) {
31183       {
31184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31185       };
31186     }
31187   }
31188 }
31189
31190
31191 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
31192   float jresult ;
31193   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31194   float result;
31195
31196   arg1 = (Dali::Actor *)jarg1;
31197   {
31198     try {
31199       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
31200     } catch (std::out_of_range& e) {
31201       {
31202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31203       };
31204     } catch (std::exception& e) {
31205       {
31206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31207       };
31208     } catch (...) {
31209       {
31210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31211       };
31212     }
31213   }
31214   jresult = result;
31215   return jresult;
31216 }
31217
31218
31219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
31220   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31221   Dali::Vector4 *arg2 = 0 ;
31222
31223   arg1 = (Dali::Actor *)jarg1;
31224   arg2 = (Dali::Vector4 *)jarg2;
31225   if (!arg2) {
31226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
31227     return ;
31228   }
31229   {
31230     try {
31231       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
31232     } catch (std::out_of_range& e) {
31233       {
31234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31235       };
31236     } catch (std::exception& e) {
31237       {
31238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31239       };
31240     } catch (...) {
31241       {
31242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31243       };
31244     }
31245   }
31246 }
31247
31248
31249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
31250   void * jresult ;
31251   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31252   Dali::Vector4 result;
31253
31254   arg1 = (Dali::Actor *)jarg1;
31255   {
31256     try {
31257       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
31258     } catch (std::out_of_range& e) {
31259       {
31260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31261       };
31262     } catch (std::exception& e) {
31263       {
31264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31265       };
31266     } catch (...) {
31267       {
31268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31269       };
31270     }
31271   }
31272   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31273   return jresult;
31274 }
31275
31276
31277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31278   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31279   Dali::ColorMode arg2 ;
31280
31281   arg1 = (Dali::Actor *)jarg1;
31282   arg2 = (Dali::ColorMode)jarg2;
31283   {
31284     try {
31285       (arg1)->SetColorMode(arg2);
31286     } catch (std::out_of_range& e) {
31287       {
31288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31289       };
31290     } catch (std::exception& e) {
31291       {
31292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31293       };
31294     } catch (...) {
31295       {
31296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31297       };
31298     }
31299   }
31300 }
31301
31302
31303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31304   int jresult ;
31305   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31306   Dali::ColorMode result;
31307
31308   arg1 = (Dali::Actor *)jarg1;
31309   {
31310     try {
31311       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31312     } catch (std::out_of_range& e) {
31313       {
31314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31315       };
31316     } catch (std::exception& e) {
31317       {
31318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31319       };
31320     } catch (...) {
31321       {
31322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31323       };
31324     }
31325   }
31326   jresult = (int)result;
31327   return jresult;
31328 }
31329
31330
31331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31332   void * jresult ;
31333   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31334   Dali::Vector4 result;
31335
31336   arg1 = (Dali::Actor *)jarg1;
31337   {
31338     try {
31339       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31340     } catch (std::out_of_range& e) {
31341       {
31342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31343       };
31344     } catch (std::exception& e) {
31345       {
31346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31347       };
31348     } catch (...) {
31349       {
31350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31351       };
31352     }
31353   }
31354   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31355   return jresult;
31356 }
31357
31358
31359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31360   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31361   Dali::DrawMode::Type arg2 ;
31362
31363   arg1 = (Dali::Actor *)jarg1;
31364   arg2 = (Dali::DrawMode::Type)jarg2;
31365   {
31366     try {
31367       (arg1)->SetDrawMode(arg2);
31368     } catch (std::out_of_range& e) {
31369       {
31370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31371       };
31372     } catch (std::exception& e) {
31373       {
31374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31375       };
31376     } catch (...) {
31377       {
31378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31379       };
31380     }
31381   }
31382 }
31383
31384
31385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31386   int jresult ;
31387   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31388   Dali::DrawMode::Type result;
31389
31390   arg1 = (Dali::Actor *)jarg1;
31391   {
31392     try {
31393       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31394     } catch (std::out_of_range& e) {
31395       {
31396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31397       };
31398     } catch (std::exception& e) {
31399       {
31400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31401       };
31402     } catch (...) {
31403       {
31404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31405       };
31406     }
31407   }
31408   jresult = (int)result;
31409   return jresult;
31410 }
31411
31412
31413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31414   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31415   bool arg2 ;
31416
31417   arg1 = (Dali::Actor *)jarg1;
31418   arg2 = jarg2 ? true : false;
31419   {
31420     try {
31421       (arg1)->SetSensitive(arg2);
31422     } catch (std::out_of_range& e) {
31423       {
31424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31425       };
31426     } catch (std::exception& e) {
31427       {
31428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31429       };
31430     } catch (...) {
31431       {
31432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31433       };
31434     }
31435   }
31436 }
31437
31438
31439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31440   unsigned int jresult ;
31441   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31442   bool result;
31443
31444   arg1 = (Dali::Actor *)jarg1;
31445   {
31446     try {
31447       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31448     } catch (std::out_of_range& e) {
31449       {
31450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31451       };
31452     } catch (std::exception& e) {
31453       {
31454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31455       };
31456     } catch (...) {
31457       {
31458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31459       };
31460     }
31461   }
31462   jresult = result;
31463   return jresult;
31464 }
31465
31466
31467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31468   unsigned int jresult ;
31469   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31470   float *arg2 = 0 ;
31471   float *arg3 = 0 ;
31472   float arg4 ;
31473   float arg5 ;
31474   bool result;
31475
31476   arg1 = (Dali::Actor *)jarg1;
31477   arg2 = (float *)jarg2;
31478   arg3 = (float *)jarg3;
31479   arg4 = (float)jarg4;
31480   arg5 = (float)jarg5;
31481   {
31482     try {
31483       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31484     } catch (std::out_of_range& e) {
31485       {
31486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31487       };
31488     } catch (std::exception& e) {
31489       {
31490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31491       };
31492     } catch (...) {
31493       {
31494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31495       };
31496     }
31497   }
31498   jresult = result;
31499   return jresult;
31500 }
31501
31502
31503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31504   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31505   bool arg2 ;
31506
31507   arg1 = (Dali::Actor *)jarg1;
31508   arg2 = jarg2 ? true : false;
31509   {
31510     try {
31511       (arg1)->SetLeaveRequired(arg2);
31512     } catch (std::out_of_range& e) {
31513       {
31514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31515       };
31516     } catch (std::exception& e) {
31517       {
31518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31519       };
31520     } catch (...) {
31521       {
31522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31523       };
31524     }
31525   }
31526 }
31527
31528
31529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31530   unsigned int jresult ;
31531   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31532   bool result;
31533
31534   arg1 = (Dali::Actor *)jarg1;
31535   {
31536     try {
31537       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31538     } catch (std::out_of_range& e) {
31539       {
31540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31541       };
31542     } catch (std::exception& e) {
31543       {
31544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31545       };
31546     } catch (...) {
31547       {
31548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31549       };
31550     }
31551   }
31552   jresult = result;
31553   return jresult;
31554 }
31555
31556
31557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31558   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31559   bool arg2 ;
31560
31561   arg1 = (Dali::Actor *)jarg1;
31562   arg2 = jarg2 ? true : false;
31563   {
31564     try {
31565       (arg1)->SetKeyboardFocusable(arg2);
31566     } catch (std::out_of_range& e) {
31567       {
31568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31569       };
31570     } catch (std::exception& e) {
31571       {
31572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31573       };
31574     } catch (...) {
31575       {
31576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31577       };
31578     }
31579   }
31580 }
31581
31582
31583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31584   unsigned int jresult ;
31585   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31586   bool result;
31587
31588   arg1 = (Dali::Actor *)jarg1;
31589   {
31590     try {
31591       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31592     } catch (std::out_of_range& e) {
31593       {
31594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31595       };
31596     } catch (std::exception& e) {
31597       {
31598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31599       };
31600     } catch (...) {
31601       {
31602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31603       };
31604     }
31605   }
31606   jresult = result;
31607   return jresult;
31608 }
31609
31610
31611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31612   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31613   Dali::ResizePolicy::Type arg2 ;
31614   Dali::Dimension::Type arg3 ;
31615
31616   arg1 = (Dali::Actor *)jarg1;
31617   arg2 = (Dali::ResizePolicy::Type)jarg2;
31618   arg3 = (Dali::Dimension::Type)jarg3;
31619   {
31620     try {
31621       (arg1)->SetResizePolicy(arg2,arg3);
31622     } catch (std::out_of_range& e) {
31623       {
31624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31625       };
31626     } catch (std::exception& e) {
31627       {
31628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31629       };
31630     } catch (...) {
31631       {
31632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31633       };
31634     }
31635   }
31636 }
31637
31638
31639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31640   int jresult ;
31641   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31642   Dali::Dimension::Type arg2 ;
31643   Dali::ResizePolicy::Type result;
31644
31645   arg1 = (Dali::Actor *)jarg1;
31646   arg2 = (Dali::Dimension::Type)jarg2;
31647   {
31648     try {
31649       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31650     } catch (std::out_of_range& e) {
31651       {
31652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31653       };
31654     } catch (std::exception& e) {
31655       {
31656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31657       };
31658     } catch (...) {
31659       {
31660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31661       };
31662     }
31663   }
31664   jresult = (int)result;
31665   return jresult;
31666 }
31667
31668
31669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31670   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31671   Dali::SizeScalePolicy::Type arg2 ;
31672
31673   arg1 = (Dali::Actor *)jarg1;
31674   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31675   {
31676     try {
31677       (arg1)->SetSizeScalePolicy(arg2);
31678     } catch (std::out_of_range& e) {
31679       {
31680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31681       };
31682     } catch (std::exception& e) {
31683       {
31684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31685       };
31686     } catch (...) {
31687       {
31688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31689       };
31690     }
31691   }
31692 }
31693
31694
31695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31696   int jresult ;
31697   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31698   Dali::SizeScalePolicy::Type result;
31699
31700   arg1 = (Dali::Actor *)jarg1;
31701   {
31702     try {
31703       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31704     } catch (std::out_of_range& e) {
31705       {
31706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31707       };
31708     } catch (std::exception& e) {
31709       {
31710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31711       };
31712     } catch (...) {
31713       {
31714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31715       };
31716     }
31717   }
31718   jresult = (int)result;
31719   return jresult;
31720 }
31721
31722
31723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31724   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31725   Dali::Vector3 *arg2 = 0 ;
31726
31727   arg1 = (Dali::Actor *)jarg1;
31728   arg2 = (Dali::Vector3 *)jarg2;
31729   if (!arg2) {
31730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31731     return ;
31732   }
31733   {
31734     try {
31735       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31736     } catch (std::out_of_range& e) {
31737       {
31738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31739       };
31740     } catch (std::exception& e) {
31741       {
31742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31743       };
31744     } catch (...) {
31745       {
31746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31747       };
31748     }
31749   }
31750 }
31751
31752
31753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31754   void * jresult ;
31755   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31756   Dali::Vector3 result;
31757
31758   arg1 = (Dali::Actor *)jarg1;
31759   {
31760     try {
31761       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31762     } catch (std::out_of_range& e) {
31763       {
31764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31765       };
31766     } catch (std::exception& e) {
31767       {
31768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31769       };
31770     } catch (...) {
31771       {
31772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31773       };
31774     }
31775   }
31776   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31777   return jresult;
31778 }
31779
31780
31781 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31782   float jresult ;
31783   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31784   float arg2 ;
31785   float result;
31786
31787   arg1 = (Dali::Actor *)jarg1;
31788   arg2 = (float)jarg2;
31789   {
31790     try {
31791       result = (float)(arg1)->GetHeightForWidth(arg2);
31792     } catch (std::out_of_range& e) {
31793       {
31794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31795       };
31796     } catch (std::exception& e) {
31797       {
31798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31799       };
31800     } catch (...) {
31801       {
31802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31803       };
31804     }
31805   }
31806   jresult = result;
31807   return jresult;
31808 }
31809
31810
31811 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31812   float jresult ;
31813   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31814   float arg2 ;
31815   float result;
31816
31817   arg1 = (Dali::Actor *)jarg1;
31818   arg2 = (float)jarg2;
31819   {
31820     try {
31821       result = (float)(arg1)->GetWidthForHeight(arg2);
31822     } catch (std::out_of_range& e) {
31823       {
31824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31825       };
31826     } catch (std::exception& e) {
31827       {
31828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31829       };
31830     } catch (...) {
31831       {
31832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31833       };
31834     }
31835   }
31836   jresult = result;
31837   return jresult;
31838 }
31839
31840
31841 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31842   float jresult ;
31843   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31844   Dali::Dimension::Type arg2 ;
31845   float result;
31846
31847   arg1 = (Dali::Actor *)jarg1;
31848   arg2 = (Dali::Dimension::Type)jarg2;
31849   {
31850     try {
31851       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31852     } catch (std::out_of_range& e) {
31853       {
31854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31855       };
31856     } catch (std::exception& e) {
31857       {
31858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31859       };
31860     } catch (...) {
31861       {
31862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31863       };
31864     }
31865   }
31866   jresult = result;
31867   return jresult;
31868 }
31869
31870
31871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31872   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31873   Dali::Padding *arg2 = 0 ;
31874
31875   arg1 = (Dali::Actor *)jarg1;
31876   arg2 = (Dali::Padding *)jarg2;
31877   if (!arg2) {
31878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31879     return ;
31880   }
31881   {
31882     try {
31883       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31884     } catch (std::out_of_range& e) {
31885       {
31886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31887       };
31888     } catch (std::exception& e) {
31889       {
31890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31891       };
31892     } catch (...) {
31893       {
31894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31895       };
31896     }
31897   }
31898 }
31899
31900
31901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
31902   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31903   Dali::Padding *arg2 = 0 ;
31904
31905   arg1 = (Dali::Actor *)jarg1;
31906   arg2 = (Dali::Padding *)jarg2;
31907   if (!arg2) {
31908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31909     return ;
31910   }
31911   {
31912     try {
31913       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
31914     } catch (std::out_of_range& e) {
31915       {
31916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31917       };
31918     } catch (std::exception& e) {
31919       {
31920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31921       };
31922     } catch (...) {
31923       {
31924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31925       };
31926     }
31927   }
31928 }
31929
31930
31931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
31932   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31933   Dali::Vector2 *arg2 = 0 ;
31934
31935   arg1 = (Dali::Actor *)jarg1;
31936   arg2 = (Dali::Vector2 *)jarg2;
31937   if (!arg2) {
31938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31939     return ;
31940   }
31941   {
31942     try {
31943       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31944     } catch (std::out_of_range& e) {
31945       {
31946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31947       };
31948     } catch (std::exception& e) {
31949       {
31950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31951       };
31952     } catch (...) {
31953       {
31954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31955       };
31956     }
31957   }
31958 }
31959
31960
31961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
31962   void * jresult ;
31963   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31964   Dali::Vector2 result;
31965
31966   arg1 = (Dali::Actor *)jarg1;
31967   {
31968     try {
31969       result = (arg1)->GetMinimumSize();
31970     } catch (std::out_of_range& e) {
31971       {
31972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31973       };
31974     } catch (std::exception& e) {
31975       {
31976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31977       };
31978     } catch (...) {
31979       {
31980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31981       };
31982     }
31983   }
31984   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31985   return jresult;
31986 }
31987
31988
31989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
31990   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31991   Dali::Vector2 *arg2 = 0 ;
31992
31993   arg1 = (Dali::Actor *)jarg1;
31994   arg2 = (Dali::Vector2 *)jarg2;
31995   if (!arg2) {
31996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31997     return ;
31998   }
31999   {
32000     try {
32001       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
32002     } catch (std::out_of_range& e) {
32003       {
32004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32005       };
32006     } catch (std::exception& e) {
32007       {
32008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32009       };
32010     } catch (...) {
32011       {
32012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32013       };
32014     }
32015   }
32016 }
32017
32018
32019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
32020   void * jresult ;
32021   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32022   Dali::Vector2 result;
32023
32024   arg1 = (Dali::Actor *)jarg1;
32025   {
32026     try {
32027       result = (arg1)->GetMaximumSize();
32028     } catch (std::out_of_range& e) {
32029       {
32030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32031       };
32032     } catch (std::exception& e) {
32033       {
32034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32035       };
32036     } catch (...) {
32037       {
32038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32039       };
32040     }
32041   }
32042   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32043   return jresult;
32044 }
32045
32046
32047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
32048   int jresult ;
32049   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32050   int result;
32051
32052   arg1 = (Dali::Actor *)jarg1;
32053   {
32054     try {
32055       result = (int)(arg1)->GetHierarchyDepth();
32056     } catch (std::out_of_range& e) {
32057       {
32058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32059       };
32060     } catch (std::exception& e) {
32061       {
32062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32063       };
32064     } catch (...) {
32065       {
32066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32067       };
32068     }
32069   }
32070   jresult = result;
32071   return jresult;
32072 }
32073
32074
32075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
32076   unsigned int jresult ;
32077   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32078   Dali::Renderer *arg2 = 0 ;
32079   unsigned int result;
32080
32081   arg1 = (Dali::Actor *)jarg1;
32082   arg2 = (Dali::Renderer *)jarg2;
32083   if (!arg2) {
32084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32085     return 0;
32086   }
32087   {
32088     try {
32089       result = (unsigned int)(arg1)->AddRenderer(*arg2);
32090     } catch (std::out_of_range& e) {
32091       {
32092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32093       };
32094     } catch (std::exception& e) {
32095       {
32096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32097       };
32098     } catch (...) {
32099       {
32100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32101       };
32102     }
32103   }
32104   jresult = result;
32105   return jresult;
32106 }
32107
32108
32109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
32110   unsigned int jresult ;
32111   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32112   unsigned int result;
32113
32114   arg1 = (Dali::Actor *)jarg1;
32115   {
32116     try {
32117       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
32118     } catch (std::out_of_range& e) {
32119       {
32120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32121       };
32122     } catch (std::exception& e) {
32123       {
32124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32125       };
32126     } catch (...) {
32127       {
32128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32129       };
32130     }
32131   }
32132   jresult = result;
32133   return jresult;
32134 }
32135
32136
32137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
32138   void * jresult ;
32139   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32140   unsigned int arg2 ;
32141   Dali::Renderer result;
32142
32143   arg1 = (Dali::Actor *)jarg1;
32144   arg2 = (unsigned int)jarg2;
32145   {
32146     try {
32147       result = (arg1)->GetRendererAt(arg2);
32148     } catch (std::out_of_range& e) {
32149       {
32150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32151       };
32152     } catch (std::exception& e) {
32153       {
32154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32155       };
32156     } catch (...) {
32157       {
32158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32159       };
32160     }
32161   }
32162   jresult = new Dali::Renderer((const Dali::Renderer &)result);
32163   return jresult;
32164 }
32165
32166
32167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
32168   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32169   Dali::Renderer *arg2 = 0 ;
32170
32171   arg1 = (Dali::Actor *)jarg1;
32172   arg2 = (Dali::Renderer *)jarg2;
32173   if (!arg2) {
32174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32175     return ;
32176   }
32177   {
32178     try {
32179       (arg1)->RemoveRenderer(*arg2);
32180     } catch (std::out_of_range& e) {
32181       {
32182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32183       };
32184     } catch (std::exception& e) {
32185       {
32186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32187       };
32188     } catch (...) {
32189       {
32190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32191       };
32192     }
32193   }
32194 }
32195
32196
32197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
32198   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32199   unsigned int arg2 ;
32200
32201   arg1 = (Dali::Actor *)jarg1;
32202   arg2 = (unsigned int)jarg2;
32203   {
32204     try {
32205       (arg1)->RemoveRenderer(arg2);
32206     } catch (std::out_of_range& e) {
32207       {
32208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32209       };
32210     } catch (std::exception& e) {
32211       {
32212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32213       };
32214     } catch (...) {
32215       {
32216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32217       };
32218     }
32219   }
32220 }
32221
32222
32223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
32224   void * jresult ;
32225   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32226   Dali::Actor::TouchSignalType *result = 0 ;
32227
32228   arg1 = (Dali::Actor *)jarg1;
32229   {
32230     try {
32231       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
32232     } catch (std::out_of_range& e) {
32233       {
32234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32235       };
32236     } catch (std::exception& e) {
32237       {
32238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32239       };
32240     } catch (...) {
32241       {
32242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32243       };
32244     }
32245   }
32246   jresult = (void *)result;
32247   return jresult;
32248 }
32249
32250
32251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
32252   void * jresult ;
32253   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32254   Dali::Actor::TouchDataSignalType *result = 0 ;
32255
32256   arg1 = (Dali::Actor *)jarg1;
32257   {
32258     try {
32259       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
32260     } catch (std::out_of_range& e) {
32261       {
32262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32263       };
32264     } catch (std::exception& e) {
32265       {
32266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32267       };
32268     } catch (...) {
32269       {
32270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32271       };
32272     }
32273   }
32274   jresult = (void *)result;
32275   return jresult;
32276 }
32277
32278
32279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32280   void * jresult ;
32281   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32282   Dali::Actor::HoverSignalType *result = 0 ;
32283
32284   arg1 = (Dali::Actor *)jarg1;
32285   {
32286     try {
32287       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32288     } catch (std::out_of_range& e) {
32289       {
32290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32291       };
32292     } catch (std::exception& e) {
32293       {
32294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32295       };
32296     } catch (...) {
32297       {
32298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32299       };
32300     }
32301   }
32302   jresult = (void *)result;
32303   return jresult;
32304 }
32305
32306
32307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32308   void * jresult ;
32309   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32310   Dali::Actor::WheelEventSignalType *result = 0 ;
32311
32312   arg1 = (Dali::Actor *)jarg1;
32313   {
32314     try {
32315       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32316     } catch (std::out_of_range& e) {
32317       {
32318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32319       };
32320     } catch (std::exception& e) {
32321       {
32322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32323       };
32324     } catch (...) {
32325       {
32326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32327       };
32328     }
32329   }
32330   jresult = (void *)result;
32331   return jresult;
32332 }
32333
32334
32335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32336   void * jresult ;
32337   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32338   Dali::Actor::OnStageSignalType *result = 0 ;
32339
32340   arg1 = (Dali::Actor *)jarg1;
32341   {
32342     try {
32343       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32344     } catch (std::out_of_range& e) {
32345       {
32346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32347       };
32348     } catch (std::exception& e) {
32349       {
32350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32351       };
32352     } catch (...) {
32353       {
32354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32355       };
32356     }
32357   }
32358   jresult = (void *)result;
32359   return jresult;
32360 }
32361
32362
32363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32364   void * jresult ;
32365   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32366   Dali::Actor::OffStageSignalType *result = 0 ;
32367
32368   arg1 = (Dali::Actor *)jarg1;
32369   {
32370     try {
32371       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32372     } catch (std::out_of_range& e) {
32373       {
32374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32375       };
32376     } catch (std::exception& e) {
32377       {
32378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32379       };
32380     } catch (...) {
32381       {
32382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32383       };
32384     }
32385   }
32386   jresult = (void *)result;
32387   return jresult;
32388 }
32389
32390
32391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32392   void * jresult ;
32393   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32394   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32395
32396   arg1 = (Dali::Actor *)jarg1;
32397   {
32398     try {
32399       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32400     } catch (std::out_of_range& e) {
32401       {
32402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32403       };
32404     } catch (std::exception& e) {
32405       {
32406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32407       };
32408     } catch (...) {
32409       {
32410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32411       };
32412     }
32413   }
32414   jresult = (void *)result;
32415   return jresult;
32416 }
32417
32418
32419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32420   Dali::Actor *arg1 = 0 ;
32421
32422   arg1 = (Dali::Actor *)jarg1;
32423   if (!arg1) {
32424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32425     return ;
32426   }
32427   {
32428     try {
32429       Dali::UnparentAndReset(*arg1);
32430     } catch (std::out_of_range& e) {
32431       {
32432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32433       };
32434     } catch (std::exception& e) {
32435       {
32436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32437       };
32438     } catch (...) {
32439       {
32440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32441       };
32442     }
32443   }
32444 }
32445
32446
32447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32448   int jresult ;
32449   int result;
32450
32451   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32452   jresult = (int)result;
32453   return jresult;
32454 }
32455
32456
32457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32458   int jresult ;
32459   int result;
32460
32461   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32462   jresult = (int)result;
32463   return jresult;
32464 }
32465
32466
32467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32468   int jresult ;
32469   int result;
32470
32471   result = (int)Dali::Layer::Property::BEHAVIOR;
32472   jresult = (int)result;
32473   return jresult;
32474 }
32475
32476
32477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32478   void * jresult ;
32479   Dali::Layer::Property *result = 0 ;
32480
32481   {
32482     try {
32483       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32484     } catch (std::out_of_range& e) {
32485       {
32486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32487       };
32488     } catch (std::exception& e) {
32489       {
32490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32491       };
32492     } catch (...) {
32493       {
32494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32495       };
32496     }
32497   }
32498   jresult = (void *)result;
32499   return jresult;
32500 }
32501
32502
32503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32504   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32505
32506   arg1 = (Dali::Layer::Property *)jarg1;
32507   {
32508     try {
32509       delete arg1;
32510     } catch (std::out_of_range& e) {
32511       {
32512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32513       };
32514     } catch (std::exception& e) {
32515       {
32516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32517       };
32518     } catch (...) {
32519       {
32520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32521       };
32522     }
32523   }
32524 }
32525
32526
32527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32528   void * jresult ;
32529   Dali::Layer *result = 0 ;
32530
32531   {
32532     try {
32533       result = (Dali::Layer *)new Dali::Layer();
32534     } catch (std::out_of_range& e) {
32535       {
32536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32537       };
32538     } catch (std::exception& e) {
32539       {
32540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32541       };
32542     } catch (...) {
32543       {
32544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32545       };
32546     }
32547   }
32548   jresult = (void *)result;
32549   return jresult;
32550 }
32551
32552
32553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32554   void * jresult ;
32555   Dali::Layer result;
32556
32557   {
32558     try {
32559       result = Dali::Layer::New();
32560     } catch (std::out_of_range& e) {
32561       {
32562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32563       };
32564     } catch (std::exception& e) {
32565       {
32566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32567       };
32568     } catch (...) {
32569       {
32570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32571       };
32572     }
32573   }
32574   jresult = new Dali::Layer((const Dali::Layer &)result);
32575   return jresult;
32576 }
32577
32578
32579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32580   void * jresult ;
32581   Dali::BaseHandle arg1 ;
32582   Dali::BaseHandle *argp1 ;
32583   Dali::Layer result;
32584
32585   argp1 = (Dali::BaseHandle *)jarg1;
32586   if (!argp1) {
32587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32588     return 0;
32589   }
32590   arg1 = *argp1;
32591   {
32592     try {
32593       result = Dali::Layer::DownCast(arg1);
32594     } catch (std::out_of_range& e) {
32595       {
32596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32597       };
32598     } catch (std::exception& e) {
32599       {
32600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32601       };
32602     } catch (...) {
32603       {
32604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32605       };
32606     }
32607   }
32608   jresult = new Dali::Layer((const Dali::Layer &)result);
32609   return jresult;
32610 }
32611
32612
32613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32614   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32615
32616   arg1 = (Dali::Layer *)jarg1;
32617   {
32618     try {
32619       delete arg1;
32620     } catch (std::out_of_range& e) {
32621       {
32622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32623       };
32624     } catch (std::exception& e) {
32625       {
32626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32627       };
32628     } catch (...) {
32629       {
32630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32631       };
32632     }
32633   }
32634 }
32635
32636
32637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32638   void * jresult ;
32639   Dali::Layer *arg1 = 0 ;
32640   Dali::Layer *result = 0 ;
32641
32642   arg1 = (Dali::Layer *)jarg1;
32643   if (!arg1) {
32644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32645     return 0;
32646   }
32647   {
32648     try {
32649       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32650     } catch (std::out_of_range& e) {
32651       {
32652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32653       };
32654     } catch (std::exception& e) {
32655       {
32656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32657       };
32658     } catch (...) {
32659       {
32660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32661       };
32662     }
32663   }
32664   jresult = (void *)result;
32665   return jresult;
32666 }
32667
32668
32669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32670   void * jresult ;
32671   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32672   Dali::Layer *arg2 = 0 ;
32673   Dali::Layer *result = 0 ;
32674
32675   arg1 = (Dali::Layer *)jarg1;
32676   arg2 = (Dali::Layer *)jarg2;
32677   if (!arg2) {
32678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32679     return 0;
32680   }
32681   {
32682     try {
32683       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32684     } catch (std::out_of_range& e) {
32685       {
32686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32687       };
32688     } catch (std::exception& e) {
32689       {
32690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32691       };
32692     } catch (...) {
32693       {
32694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32695       };
32696     }
32697   }
32698   jresult = (void *)result;
32699   return jresult;
32700 }
32701
32702
32703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32704   unsigned int jresult ;
32705   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32706   unsigned int result;
32707
32708   arg1 = (Dali::Layer *)jarg1;
32709   {
32710     try {
32711       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32712     } catch (std::out_of_range& e) {
32713       {
32714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32715       };
32716     } catch (std::exception& e) {
32717       {
32718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32719       };
32720     } catch (...) {
32721       {
32722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32723       };
32724     }
32725   }
32726   jresult = result;
32727   return jresult;
32728 }
32729
32730
32731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32732   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32733
32734   arg1 = (Dali::Layer *)jarg1;
32735   {
32736     try {
32737       (arg1)->Raise();
32738     } catch (std::out_of_range& e) {
32739       {
32740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32741       };
32742     } catch (std::exception& e) {
32743       {
32744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32745       };
32746     } catch (...) {
32747       {
32748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32749       };
32750     }
32751   }
32752 }
32753
32754
32755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32756   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32757
32758   arg1 = (Dali::Layer *)jarg1;
32759   {
32760     try {
32761       (arg1)->Lower();
32762     } catch (std::out_of_range& e) {
32763       {
32764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32765       };
32766     } catch (std::exception& e) {
32767       {
32768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32769       };
32770     } catch (...) {
32771       {
32772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32773       };
32774     }
32775   }
32776 }
32777
32778
32779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32780   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32781   Dali::Layer arg2 ;
32782   Dali::Layer *argp2 ;
32783
32784   arg1 = (Dali::Layer *)jarg1;
32785   argp2 = (Dali::Layer *)jarg2;
32786   if (!argp2) {
32787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32788     return ;
32789   }
32790   arg2 = *argp2;
32791   {
32792     try {
32793       (arg1)->RaiseAbove(arg2);
32794     } catch (std::out_of_range& e) {
32795       {
32796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32797       };
32798     } catch (std::exception& e) {
32799       {
32800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32801       };
32802     } catch (...) {
32803       {
32804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32805       };
32806     }
32807   }
32808 }
32809
32810
32811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32812   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32813   Dali::Layer arg2 ;
32814   Dali::Layer *argp2 ;
32815
32816   arg1 = (Dali::Layer *)jarg1;
32817   argp2 = (Dali::Layer *)jarg2;
32818   if (!argp2) {
32819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32820     return ;
32821   }
32822   arg2 = *argp2;
32823   {
32824     try {
32825       (arg1)->LowerBelow(arg2);
32826     } catch (std::out_of_range& e) {
32827       {
32828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32829       };
32830     } catch (std::exception& e) {
32831       {
32832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32833       };
32834     } catch (...) {
32835       {
32836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32837       };
32838     }
32839   }
32840 }
32841
32842
32843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32844   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32845
32846   arg1 = (Dali::Layer *)jarg1;
32847   {
32848     try {
32849       (arg1)->RaiseToTop();
32850     } catch (std::out_of_range& e) {
32851       {
32852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32853       };
32854     } catch (std::exception& e) {
32855       {
32856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32857       };
32858     } catch (...) {
32859       {
32860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32861       };
32862     }
32863   }
32864 }
32865
32866
32867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32868   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32869
32870   arg1 = (Dali::Layer *)jarg1;
32871   {
32872     try {
32873       (arg1)->LowerToBottom();
32874     } catch (std::out_of_range& e) {
32875       {
32876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32877       };
32878     } catch (std::exception& e) {
32879       {
32880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32881       };
32882     } catch (...) {
32883       {
32884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32885       };
32886     }
32887   }
32888 }
32889
32890
32891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32892   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32893   Dali::Layer arg2 ;
32894   Dali::Layer *argp2 ;
32895
32896   arg1 = (Dali::Layer *)jarg1;
32897   argp2 = (Dali::Layer *)jarg2;
32898   if (!argp2) {
32899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32900     return ;
32901   }
32902   arg2 = *argp2;
32903   {
32904     try {
32905       (arg1)->MoveAbove(arg2);
32906     } catch (std::out_of_range& e) {
32907       {
32908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32909       };
32910     } catch (std::exception& e) {
32911       {
32912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32913       };
32914     } catch (...) {
32915       {
32916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32917       };
32918     }
32919   }
32920 }
32921
32922
32923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
32924   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32925   Dali::Layer arg2 ;
32926   Dali::Layer *argp2 ;
32927
32928   arg1 = (Dali::Layer *)jarg1;
32929   argp2 = (Dali::Layer *)jarg2;
32930   if (!argp2) {
32931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32932     return ;
32933   }
32934   arg2 = *argp2;
32935   {
32936     try {
32937       (arg1)->MoveBelow(arg2);
32938     } catch (std::out_of_range& e) {
32939       {
32940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32941       };
32942     } catch (std::exception& e) {
32943       {
32944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32945       };
32946     } catch (...) {
32947       {
32948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32949       };
32950     }
32951   }
32952 }
32953
32954
32955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
32956   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32957   Dali::Layer::Behavior arg2 ;
32958
32959   arg1 = (Dali::Layer *)jarg1;
32960   arg2 = (Dali::Layer::Behavior)jarg2;
32961   {
32962     try {
32963       (arg1)->SetBehavior(arg2);
32964     } catch (std::out_of_range& e) {
32965       {
32966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32967       };
32968     } catch (std::exception& e) {
32969       {
32970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32971       };
32972     } catch (...) {
32973       {
32974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32975       };
32976     }
32977   }
32978 }
32979
32980
32981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
32982   int jresult ;
32983   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32984   Dali::Layer::Behavior result;
32985
32986   arg1 = (Dali::Layer *)jarg1;
32987   {
32988     try {
32989       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
32990     } catch (std::out_of_range& e) {
32991       {
32992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32993       };
32994     } catch (std::exception& e) {
32995       {
32996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32997       };
32998     } catch (...) {
32999       {
33000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33001       };
33002     }
33003   }
33004   jresult = (int)result;
33005   return jresult;
33006 }
33007
33008
33009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
33010   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33011   bool arg2 ;
33012
33013   arg1 = (Dali::Layer *)jarg1;
33014   arg2 = jarg2 ? true : false;
33015   {
33016     try {
33017       (arg1)->SetClipping(arg2);
33018     } catch (std::out_of_range& e) {
33019       {
33020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33021       };
33022     } catch (std::exception& e) {
33023       {
33024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33025       };
33026     } catch (...) {
33027       {
33028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33029       };
33030     }
33031   }
33032 }
33033
33034
33035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
33036   unsigned int jresult ;
33037   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33038   bool result;
33039
33040   arg1 = (Dali::Layer *)jarg1;
33041   {
33042     try {
33043       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
33044     } catch (std::out_of_range& e) {
33045       {
33046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33047       };
33048     } catch (std::exception& e) {
33049       {
33050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33051       };
33052     } catch (...) {
33053       {
33054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33055       };
33056     }
33057   }
33058   jresult = result;
33059   return jresult;
33060 }
33061
33062
33063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
33064   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33065   int arg2 ;
33066   int arg3 ;
33067   int arg4 ;
33068   int arg5 ;
33069
33070   arg1 = (Dali::Layer *)jarg1;
33071   arg2 = (int)jarg2;
33072   arg3 = (int)jarg3;
33073   arg4 = (int)jarg4;
33074   arg5 = (int)jarg5;
33075   {
33076     try {
33077       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
33078     } catch (std::out_of_range& e) {
33079       {
33080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33081       };
33082     } catch (std::exception& e) {
33083       {
33084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33085       };
33086     } catch (...) {
33087       {
33088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33089       };
33090     }
33091   }
33092 }
33093
33094
33095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33096   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33097   Dali::ClippingBox arg2 ;
33098   Dali::ClippingBox *argp2 ;
33099
33100   arg1 = (Dali::Layer *)jarg1;
33101   argp2 = (Dali::ClippingBox *)jarg2;
33102   if (!argp2) {
33103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33104     return ;
33105   }
33106   arg2 = *argp2;
33107   {
33108     try {
33109       (arg1)->SetClippingBox(arg2);
33110     } catch (std::out_of_range& e) {
33111       {
33112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33113       };
33114     } catch (std::exception& e) {
33115       {
33116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33117       };
33118     } catch (...) {
33119       {
33120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33121       };
33122     }
33123   }
33124 }
33125
33126
33127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33128   void * jresult ;
33129   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33130   Dali::ClippingBox result;
33131
33132   arg1 = (Dali::Layer *)jarg1;
33133   {
33134     try {
33135       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33136     } catch (std::out_of_range& e) {
33137       {
33138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33139       };
33140     } catch (std::exception& e) {
33141       {
33142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33143       };
33144     } catch (...) {
33145       {
33146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33147       };
33148     }
33149   }
33150   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33151   return jresult;
33152 }
33153
33154
33155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33156   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33157   bool arg2 ;
33158
33159   arg1 = (Dali::Layer *)jarg1;
33160   arg2 = jarg2 ? true : false;
33161   {
33162     try {
33163       (arg1)->SetDepthTestDisabled(arg2);
33164     } catch (std::out_of_range& e) {
33165       {
33166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33167       };
33168     } catch (std::exception& e) {
33169       {
33170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33171       };
33172     } catch (...) {
33173       {
33174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33175       };
33176     }
33177   }
33178 }
33179
33180
33181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33182   unsigned int jresult ;
33183   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33184   bool result;
33185
33186   arg1 = (Dali::Layer *)jarg1;
33187   {
33188     try {
33189       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33190     } catch (std::out_of_range& e) {
33191       {
33192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33193       };
33194     } catch (std::exception& e) {
33195       {
33196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33197       };
33198     } catch (...) {
33199       {
33200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33201       };
33202     }
33203   }
33204   jresult = result;
33205   return jresult;
33206 }
33207
33208
33209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33210   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33211   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33212
33213   arg1 = (Dali::Layer *)jarg1;
33214   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33215   {
33216     try {
33217       (arg1)->SetSortFunction(arg2);
33218     } catch (std::out_of_range& e) {
33219       {
33220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33221       };
33222     } catch (std::exception& e) {
33223       {
33224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33225       };
33226     } catch (...) {
33227       {
33228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33229       };
33230     }
33231   }
33232 }
33233
33234
33235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33236   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33237   bool arg2 ;
33238
33239   arg1 = (Dali::Layer *)jarg1;
33240   arg2 = jarg2 ? true : false;
33241   {
33242     try {
33243       (arg1)->SetTouchConsumed(arg2);
33244     } catch (std::out_of_range& e) {
33245       {
33246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33247       };
33248     } catch (std::exception& e) {
33249       {
33250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33251       };
33252     } catch (...) {
33253       {
33254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33255       };
33256     }
33257   }
33258 }
33259
33260
33261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33262   unsigned int jresult ;
33263   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33264   bool result;
33265
33266   arg1 = (Dali::Layer *)jarg1;
33267   {
33268     try {
33269       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33270     } catch (std::out_of_range& e) {
33271       {
33272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33273       };
33274     } catch (std::exception& e) {
33275       {
33276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33277       };
33278     } catch (...) {
33279       {
33280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33281       };
33282     }
33283   }
33284   jresult = result;
33285   return jresult;
33286 }
33287
33288
33289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33290   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33291   bool arg2 ;
33292
33293   arg1 = (Dali::Layer *)jarg1;
33294   arg2 = jarg2 ? true : false;
33295   {
33296     try {
33297       (arg1)->SetHoverConsumed(arg2);
33298     } catch (std::out_of_range& e) {
33299       {
33300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33301       };
33302     } catch (std::exception& e) {
33303       {
33304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33305       };
33306     } catch (...) {
33307       {
33308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33309       };
33310     }
33311   }
33312 }
33313
33314
33315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33316   unsigned int jresult ;
33317   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33318   bool result;
33319
33320   arg1 = (Dali::Layer *)jarg1;
33321   {
33322     try {
33323       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33324     } catch (std::out_of_range& e) {
33325       {
33326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33327       };
33328     } catch (std::exception& e) {
33329       {
33330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33331       };
33332     } catch (...) {
33333       {
33334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33335       };
33336     }
33337   }
33338   jresult = result;
33339   return jresult;
33340 }
33341
33342
33343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33344   void * jresult ;
33345   Dali::Vector4 *result = 0 ;
33346
33347   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33348   jresult = (void *)result;
33349   return jresult;
33350 }
33351
33352
33353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33354   void * jresult ;
33355   Dali::Vector4 *result = 0 ;
33356
33357   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33358   jresult = (void *)result;
33359   return jresult;
33360 }
33361
33362
33363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33364   void * jresult ;
33365   Dali::Stage *result = 0 ;
33366
33367   {
33368     try {
33369       result = (Dali::Stage *)new Dali::Stage();
33370     } catch (std::out_of_range& e) {
33371       {
33372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33373       };
33374     } catch (std::exception& e) {
33375       {
33376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33377       };
33378     } catch (...) {
33379       {
33380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33381       };
33382     }
33383   }
33384   jresult = (void *)result;
33385   return jresult;
33386 }
33387
33388
33389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33390   void * jresult ;
33391   Dali::Stage result;
33392
33393   {
33394     try {
33395       result = Dali::Stage::GetCurrent();
33396     } catch (std::out_of_range& e) {
33397       {
33398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33399       };
33400     } catch (std::exception& e) {
33401       {
33402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33403       };
33404     } catch (...) {
33405       {
33406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33407       };
33408     }
33409   }
33410   jresult = new Dali::Stage((const Dali::Stage &)result);
33411   return jresult;
33412 }
33413
33414
33415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33416   unsigned int jresult ;
33417   bool result;
33418
33419   {
33420     try {
33421       result = (bool)Dali::Stage::IsInstalled();
33422     } catch (std::out_of_range& e) {
33423       {
33424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33425       };
33426     } catch (std::exception& e) {
33427       {
33428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33429       };
33430     } catch (...) {
33431       {
33432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33433       };
33434     }
33435   }
33436   jresult = result;
33437   return jresult;
33438 }
33439
33440
33441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33442   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33443
33444   arg1 = (Dali::Stage *)jarg1;
33445   {
33446     try {
33447       delete arg1;
33448     } catch (std::out_of_range& e) {
33449       {
33450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33451       };
33452     } catch (std::exception& e) {
33453       {
33454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33455       };
33456     } catch (...) {
33457       {
33458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33459       };
33460     }
33461   }
33462 }
33463
33464
33465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33466   void * jresult ;
33467   Dali::Stage *arg1 = 0 ;
33468   Dali::Stage *result = 0 ;
33469
33470   arg1 = (Dali::Stage *)jarg1;
33471   if (!arg1) {
33472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33473     return 0;
33474   }
33475   {
33476     try {
33477       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33478     } catch (std::out_of_range& e) {
33479       {
33480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33481       };
33482     } catch (std::exception& e) {
33483       {
33484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33485       };
33486     } catch (...) {
33487       {
33488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33489       };
33490     }
33491   }
33492   jresult = (void *)result;
33493   return jresult;
33494 }
33495
33496
33497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33498   void * jresult ;
33499   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33500   Dali::Stage *arg2 = 0 ;
33501   Dali::Stage *result = 0 ;
33502
33503   arg1 = (Dali::Stage *)jarg1;
33504   arg2 = (Dali::Stage *)jarg2;
33505   if (!arg2) {
33506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33507     return 0;
33508   }
33509   {
33510     try {
33511       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33512     } catch (std::out_of_range& e) {
33513       {
33514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33515       };
33516     } catch (std::exception& e) {
33517       {
33518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33519       };
33520     } catch (...) {
33521       {
33522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33523       };
33524     }
33525   }
33526   jresult = (void *)result;
33527   return jresult;
33528 }
33529
33530
33531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33532   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33533   Dali::Actor *arg2 = 0 ;
33534
33535   arg1 = (Dali::Stage *)jarg1;
33536   arg2 = (Dali::Actor *)jarg2;
33537   if (!arg2) {
33538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33539     return ;
33540   }
33541   {
33542     try {
33543       (arg1)->Add(*arg2);
33544     } catch (std::out_of_range& e) {
33545       {
33546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33547       };
33548     } catch (std::exception& e) {
33549       {
33550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33551       };
33552     } catch (...) {
33553       {
33554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33555       };
33556     }
33557   }
33558 }
33559
33560
33561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33562   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33563   Dali::Actor *arg2 = 0 ;
33564
33565   arg1 = (Dali::Stage *)jarg1;
33566   arg2 = (Dali::Actor *)jarg2;
33567   if (!arg2) {
33568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33569     return ;
33570   }
33571   {
33572     try {
33573       (arg1)->Remove(*arg2);
33574     } catch (std::out_of_range& e) {
33575       {
33576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33577       };
33578     } catch (std::exception& e) {
33579       {
33580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33581       };
33582     } catch (...) {
33583       {
33584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33585       };
33586     }
33587   }
33588 }
33589
33590
33591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33592   void * jresult ;
33593   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33594   Dali::Vector2 result;
33595
33596   arg1 = (Dali::Stage *)jarg1;
33597   {
33598     try {
33599       result = ((Dali::Stage const *)arg1)->GetSize();
33600     } catch (std::out_of_range& e) {
33601       {
33602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33603       };
33604     } catch (std::exception& e) {
33605       {
33606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33607       };
33608     } catch (...) {
33609       {
33610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33611       };
33612     }
33613   }
33614   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33615   return jresult;
33616 }
33617
33618
33619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33620   void * jresult ;
33621   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33622   Dali::RenderTaskList result;
33623
33624   arg1 = (Dali::Stage *)jarg1;
33625   {
33626     try {
33627       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33628     } catch (std::out_of_range& e) {
33629       {
33630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33631       };
33632     } catch (std::exception& e) {
33633       {
33634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33635       };
33636     } catch (...) {
33637       {
33638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33639       };
33640     }
33641   }
33642   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33643   return jresult;
33644 }
33645
33646
33647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33648   unsigned int jresult ;
33649   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33650   unsigned int result;
33651
33652   arg1 = (Dali::Stage *)jarg1;
33653   {
33654     try {
33655       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33656     } catch (std::out_of_range& e) {
33657       {
33658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33659       };
33660     } catch (std::exception& e) {
33661       {
33662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33663       };
33664     } catch (...) {
33665       {
33666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33667       };
33668     }
33669   }
33670   jresult = result;
33671   return jresult;
33672 }
33673
33674
33675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33676   void * jresult ;
33677   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33678   unsigned int arg2 ;
33679   Dali::Layer result;
33680
33681   arg1 = (Dali::Stage *)jarg1;
33682   arg2 = (unsigned int)jarg2;
33683   {
33684     try {
33685       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33686     } catch (std::out_of_range& e) {
33687       {
33688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33689       };
33690     } catch (std::exception& e) {
33691       {
33692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33693       };
33694     } catch (...) {
33695       {
33696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33697       };
33698     }
33699   }
33700   jresult = new Dali::Layer((const Dali::Layer &)result);
33701   return jresult;
33702 }
33703
33704
33705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33706   void * jresult ;
33707   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33708   Dali::Layer result;
33709
33710   arg1 = (Dali::Stage *)jarg1;
33711   {
33712     try {
33713       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33714     } catch (std::out_of_range& e) {
33715       {
33716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33717       };
33718     } catch (std::exception& e) {
33719       {
33720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33721       };
33722     } catch (...) {
33723       {
33724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33725       };
33726     }
33727   }
33728   jresult = new Dali::Layer((const Dali::Layer &)result);
33729   return jresult;
33730 }
33731
33732
33733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33734   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33735   Dali::Vector4 arg2 ;
33736   Dali::Vector4 *argp2 ;
33737
33738   arg1 = (Dali::Stage *)jarg1;
33739   argp2 = (Dali::Vector4 *)jarg2;
33740   if (!argp2) {
33741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33742     return ;
33743   }
33744   arg2 = *argp2;
33745   {
33746     try {
33747       (arg1)->SetBackgroundColor(arg2);
33748     } catch (std::out_of_range& e) {
33749       {
33750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33751       };
33752     } catch (std::exception& e) {
33753       {
33754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33755       };
33756     } catch (...) {
33757       {
33758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33759       };
33760     }
33761   }
33762 }
33763
33764
33765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33766   void * jresult ;
33767   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33768   Dali::Vector4 result;
33769
33770   arg1 = (Dali::Stage *)jarg1;
33771   {
33772     try {
33773       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33774     } catch (std::out_of_range& e) {
33775       {
33776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33777       };
33778     } catch (std::exception& e) {
33779       {
33780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33781       };
33782     } catch (...) {
33783       {
33784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33785       };
33786     }
33787   }
33788   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33789   return jresult;
33790 }
33791
33792
33793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33794   void * jresult ;
33795   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33796   Dali::Vector2 result;
33797
33798   arg1 = (Dali::Stage *)jarg1;
33799   {
33800     try {
33801       result = ((Dali::Stage const *)arg1)->GetDpi();
33802     } catch (std::out_of_range& e) {
33803       {
33804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33805       };
33806     } catch (std::exception& e) {
33807       {
33808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33809       };
33810     } catch (...) {
33811       {
33812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33813       };
33814     }
33815   }
33816   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33817   return jresult;
33818 }
33819
33820
33821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33822   void * jresult ;
33823   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33824   Dali::ObjectRegistry result;
33825
33826   arg1 = (Dali::Stage *)jarg1;
33827   {
33828     try {
33829       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33830     } catch (std::out_of_range& e) {
33831       {
33832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33833       };
33834     } catch (std::exception& e) {
33835       {
33836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33837       };
33838     } catch (...) {
33839       {
33840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33841       };
33842     }
33843   }
33844   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33845   return jresult;
33846 }
33847
33848
33849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33850   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33851   float arg2 ;
33852
33853   arg1 = (Dali::Stage *)jarg1;
33854   arg2 = (float)jarg2;
33855   {
33856     try {
33857       (arg1)->KeepRendering(arg2);
33858     } catch (std::out_of_range& e) {
33859       {
33860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33861       };
33862     } catch (std::exception& e) {
33863       {
33864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33865       };
33866     } catch (...) {
33867       {
33868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33869       };
33870     }
33871   }
33872 }
33873
33874
33875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33876   void * jresult ;
33877   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33878   Dali::Stage::KeyEventSignalType *result = 0 ;
33879
33880   arg1 = (Dali::Stage *)jarg1;
33881   {
33882     try {
33883       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33884     } catch (std::out_of_range& e) {
33885       {
33886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33887       };
33888     } catch (std::exception& e) {
33889       {
33890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33891       };
33892     } catch (...) {
33893       {
33894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33895       };
33896     }
33897   }
33898   jresult = (void *)result;
33899   return jresult;
33900 }
33901
33902
33903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
33904   void * jresult ;
33905   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33906   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
33907
33908   arg1 = (Dali::Stage *)jarg1;
33909   {
33910     try {
33911       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
33912     } catch (std::out_of_range& e) {
33913       {
33914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33915       };
33916     } catch (std::exception& e) {
33917       {
33918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33919       };
33920     } catch (...) {
33921       {
33922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33923       };
33924     }
33925   }
33926   jresult = (void *)result;
33927   return jresult;
33928 }
33929
33930
33931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
33932   void * jresult ;
33933   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33934   Dali::Stage::TouchSignalType *result = 0 ;
33935
33936   arg1 = (Dali::Stage *)jarg1;
33937   {
33938     try {
33939       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
33940     } catch (std::out_of_range& e) {
33941       {
33942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33943       };
33944     } catch (std::exception& e) {
33945       {
33946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33947       };
33948     } catch (...) {
33949       {
33950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33951       };
33952     }
33953   }
33954   jresult = (void *)result;
33955   return jresult;
33956 }
33957
33958
33959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
33960   void * jresult ;
33961   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33962   Dali::Stage::WheelEventSignalType *result = 0 ;
33963
33964   arg1 = (Dali::Stage *)jarg1;
33965   {
33966     try {
33967       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
33968     } catch (std::out_of_range& e) {
33969       {
33970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33971       };
33972     } catch (std::exception& e) {
33973       {
33974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33975       };
33976     } catch (...) {
33977       {
33978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33979       };
33980     }
33981   }
33982   jresult = (void *)result;
33983   return jresult;
33984 }
33985
33986
33987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
33988   void * jresult ;
33989   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33990   Dali::Stage::ContextStatusSignal *result = 0 ;
33991
33992   arg1 = (Dali::Stage *)jarg1;
33993   {
33994     try {
33995       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
33996     } catch (std::out_of_range& e) {
33997       {
33998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33999       };
34000     } catch (std::exception& e) {
34001       {
34002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34003       };
34004     } catch (...) {
34005       {
34006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34007       };
34008     }
34009   }
34010   jresult = (void *)result;
34011   return jresult;
34012 }
34013
34014
34015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
34016   void * jresult ;
34017   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34018   Dali::Stage::ContextStatusSignal *result = 0 ;
34019
34020   arg1 = (Dali::Stage *)jarg1;
34021   {
34022     try {
34023       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
34024     } catch (std::out_of_range& e) {
34025       {
34026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34027       };
34028     } catch (std::exception& e) {
34029       {
34030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34031       };
34032     } catch (...) {
34033       {
34034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34035       };
34036     }
34037   }
34038   jresult = (void *)result;
34039   return jresult;
34040 }
34041
34042
34043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
34044   void * jresult ;
34045   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34046   Dali::Stage::SceneCreatedSignalType *result = 0 ;
34047
34048   arg1 = (Dali::Stage *)jarg1;
34049   {
34050     try {
34051       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
34052     } catch (std::out_of_range& e) {
34053       {
34054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34055       };
34056     } catch (std::exception& e) {
34057       {
34058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34059       };
34060     } catch (...) {
34061       {
34062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34063       };
34064     }
34065   }
34066   jresult = (void *)result;
34067   return jresult;
34068 }
34069
34070
34071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
34072   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34073
34074   arg1 = (Dali::RelayoutContainer *)jarg1;
34075   {
34076     try {
34077       delete arg1;
34078     } catch (std::out_of_range& e) {
34079       {
34080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34081       };
34082     } catch (std::exception& e) {
34083       {
34084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34085       };
34086     } catch (...) {
34087       {
34088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34089       };
34090     }
34091   }
34092 }
34093
34094
34095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34096   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34097   Dali::Actor *arg2 = 0 ;
34098   Dali::Vector2 *arg3 = 0 ;
34099
34100   arg1 = (Dali::RelayoutContainer *)jarg1;
34101   arg2 = (Dali::Actor *)jarg2;
34102   if (!arg2) {
34103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34104     return ;
34105   }
34106   arg3 = (Dali::Vector2 *)jarg3;
34107   if (!arg3) {
34108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34109     return ;
34110   }
34111   {
34112     try {
34113       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34114     } catch (std::out_of_range& e) {
34115       {
34116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34117       };
34118     } catch (std::exception& e) {
34119       {
34120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34121       };
34122     } catch (...) {
34123       {
34124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34125       };
34126     }
34127   }
34128 }
34129
34130
34131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34132   void * jresult ;
34133   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34134   Dali::CustomActor result;
34135
34136   arg1 = (Dali::CustomActorImpl *)jarg1;
34137   {
34138     try {
34139       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34140     } catch (std::out_of_range& e) {
34141       {
34142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34143       };
34144     } catch (std::exception& e) {
34145       {
34146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34147       };
34148     } catch (...) {
34149       {
34150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34151       };
34152     }
34153   }
34154   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34155   return jresult;
34156 }
34157
34158
34159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34160   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34161   int arg2 ;
34162
34163   arg1 = (Dali::CustomActorImpl *)jarg1;
34164   arg2 = (int)jarg2;
34165   {
34166     try {
34167       (arg1)->OnStageConnection(arg2);
34168     } catch (std::out_of_range& e) {
34169       {
34170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34171       };
34172     } catch (std::exception& e) {
34173       {
34174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34175       };
34176     } catch (...) {
34177       {
34178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34179       };
34180     }
34181   }
34182 }
34183
34184
34185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34186   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34187
34188   arg1 = (Dali::CustomActorImpl *)jarg1;
34189   {
34190     try {
34191       (arg1)->OnStageDisconnection();
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_OnChildAdd(void * jarg1, void * jarg2) {
34210   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34211   Dali::Actor *arg2 = 0 ;
34212
34213   arg1 = (Dali::CustomActorImpl *)jarg1;
34214   arg2 = (Dali::Actor *)jarg2;
34215   if (!arg2) {
34216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34217     return ;
34218   }
34219   {
34220     try {
34221       (arg1)->OnChildAdd(*arg2);
34222     } catch (std::out_of_range& e) {
34223       {
34224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34225       };
34226     } catch (std::exception& e) {
34227       {
34228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34229       };
34230     } catch (...) {
34231       {
34232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34233       };
34234     }
34235   }
34236 }
34237
34238
34239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34240   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34241   Dali::Actor *arg2 = 0 ;
34242
34243   arg1 = (Dali::CustomActorImpl *)jarg1;
34244   arg2 = (Dali::Actor *)jarg2;
34245   if (!arg2) {
34246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34247     return ;
34248   }
34249   {
34250     try {
34251       (arg1)->OnChildRemove(*arg2);
34252     } catch (std::out_of_range& e) {
34253       {
34254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34255       };
34256     } catch (std::exception& e) {
34257       {
34258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34259       };
34260     } catch (...) {
34261       {
34262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34263       };
34264     }
34265   }
34266 }
34267
34268
34269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34270   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34271   Dali::Property::Index arg2 ;
34272   Dali::Property::Value arg3 ;
34273   Dali::Property::Value *argp3 ;
34274
34275   arg1 = (Dali::CustomActorImpl *)jarg1;
34276   arg2 = (Dali::Property::Index)jarg2;
34277   argp3 = (Dali::Property::Value *)jarg3;
34278   if (!argp3) {
34279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34280     return ;
34281   }
34282   arg3 = *argp3;
34283   {
34284     try {
34285       (arg1)->OnPropertySet(arg2,arg3);
34286     } catch (std::out_of_range& e) {
34287       {
34288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34289       };
34290     } catch (std::exception& e) {
34291       {
34292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34293       };
34294     } catch (...) {
34295       {
34296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34297       };
34298     }
34299   }
34300 }
34301
34302
34303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34304   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34305   Dali::Vector3 *arg2 = 0 ;
34306
34307   arg1 = (Dali::CustomActorImpl *)jarg1;
34308   arg2 = (Dali::Vector3 *)jarg2;
34309   if (!arg2) {
34310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34311     return ;
34312   }
34313   {
34314     try {
34315       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34316     } catch (std::out_of_range& e) {
34317       {
34318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34319       };
34320     } catch (std::exception& e) {
34321       {
34322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34323       };
34324     } catch (...) {
34325       {
34326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34327       };
34328     }
34329   }
34330 }
34331
34332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34333   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34334   Dali::Animation *arg2 = 0 ;
34335   Dali::Vector3 *arg3 = 0 ;
34336
34337   arg1 = (Dali::CustomActorImpl *)jarg1;
34338   arg2 = (Dali::Animation *)jarg2;
34339   if (!arg2) {
34340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34341     return ;
34342   }
34343   arg3 = (Dali::Vector3 *)jarg3;
34344   if (!arg3) {
34345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34346     return ;
34347   }
34348   {
34349     try {
34350       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34351     } catch (std::out_of_range& e) {
34352       {
34353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34354       };
34355     } catch (std::exception& e) {
34356       {
34357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34358       };
34359     } catch (...) {
34360       {
34361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34362       };
34363     }
34364   }
34365 }
34366
34367
34368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34369   unsigned int jresult ;
34370   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34371   Dali::TouchEvent *arg2 = 0 ;
34372   bool result;
34373
34374   arg1 = (Dali::CustomActorImpl *)jarg1;
34375   arg2 = (Dali::TouchEvent *)jarg2;
34376   if (!arg2) {
34377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34378     return 0;
34379   }
34380   {
34381     try {
34382       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34383     } catch (std::out_of_range& e) {
34384       {
34385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34386       };
34387     } catch (std::exception& e) {
34388       {
34389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34390       };
34391     } catch (...) {
34392       {
34393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34394       };
34395     }
34396   }
34397   jresult = result;
34398   return jresult;
34399 }
34400
34401
34402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34403   unsigned int jresult ;
34404   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34405   Dali::HoverEvent *arg2 = 0 ;
34406   bool result;
34407
34408   arg1 = (Dali::CustomActorImpl *)jarg1;
34409   arg2 = (Dali::HoverEvent *)jarg2;
34410   if (!arg2) {
34411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34412     return 0;
34413   }
34414   {
34415     try {
34416       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34417     } catch (std::out_of_range& e) {
34418       {
34419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34420       };
34421     } catch (std::exception& e) {
34422       {
34423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34424       };
34425     } catch (...) {
34426       {
34427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34428       };
34429     }
34430   }
34431   jresult = result;
34432   return jresult;
34433 }
34434
34435
34436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34437   unsigned int jresult ;
34438   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34439   Dali::KeyEvent *arg2 = 0 ;
34440   bool result;
34441
34442   arg1 = (Dali::CustomActorImpl *)jarg1;
34443   arg2 = (Dali::KeyEvent *)jarg2;
34444   if (!arg2) {
34445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34446     return 0;
34447   }
34448   {
34449     try {
34450       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34451     } catch (std::out_of_range& e) {
34452       {
34453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34454       };
34455     } catch (std::exception& e) {
34456       {
34457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34458       };
34459     } catch (...) {
34460       {
34461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34462       };
34463     }
34464   }
34465   jresult = result;
34466   return jresult;
34467 }
34468
34469
34470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34471   unsigned int jresult ;
34472   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34473   Dali::WheelEvent *arg2 = 0 ;
34474   bool result;
34475
34476   arg1 = (Dali::CustomActorImpl *)jarg1;
34477   arg2 = (Dali::WheelEvent *)jarg2;
34478   if (!arg2) {
34479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34480     return 0;
34481   }
34482   {
34483     try {
34484       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34485     } catch (std::out_of_range& e) {
34486       {
34487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34488       };
34489     } catch (std::exception& e) {
34490       {
34491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34492       };
34493     } catch (...) {
34494       {
34495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34496       };
34497     }
34498   }
34499   jresult = result;
34500   return jresult;
34501 }
34502
34503
34504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34505   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34506   Dali::Vector2 *arg2 = 0 ;
34507   Dali::RelayoutContainer *arg3 = 0 ;
34508
34509   arg1 = (Dali::CustomActorImpl *)jarg1;
34510   arg2 = (Dali::Vector2 *)jarg2;
34511   if (!arg2) {
34512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34513     return ;
34514   }
34515   arg3 = (Dali::RelayoutContainer *)jarg3;
34516   if (!arg3) {
34517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34518     return ;
34519   }
34520   {
34521     try {
34522       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34523     } catch (std::out_of_range& e) {
34524       {
34525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34526       };
34527     } catch (std::exception& e) {
34528       {
34529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34530       };
34531     } catch (...) {
34532       {
34533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34534       };
34535     }
34536   }
34537 }
34538
34539
34540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34541   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34542   Dali::ResizePolicy::Type arg2 ;
34543   Dali::Dimension::Type arg3 ;
34544
34545   arg1 = (Dali::CustomActorImpl *)jarg1;
34546   arg2 = (Dali::ResizePolicy::Type)jarg2;
34547   arg3 = (Dali::Dimension::Type)jarg3;
34548   {
34549     try {
34550       (arg1)->OnSetResizePolicy(arg2,arg3);
34551     } catch (std::out_of_range& e) {
34552       {
34553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34554       };
34555     } catch (std::exception& e) {
34556       {
34557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34558       };
34559     } catch (...) {
34560       {
34561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34562       };
34563     }
34564   }
34565 }
34566
34567
34568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34569   void * jresult ;
34570   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34571   Dali::Vector3 result;
34572
34573   arg1 = (Dali::CustomActorImpl *)jarg1;
34574   {
34575     try {
34576       result = (arg1)->GetNaturalSize();
34577     } catch (std::out_of_range& e) {
34578       {
34579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34580       };
34581     } catch (std::exception& e) {
34582       {
34583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34584       };
34585     } catch (...) {
34586       {
34587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34588       };
34589     }
34590   }
34591   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34592   return jresult;
34593 }
34594
34595
34596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34597   float jresult ;
34598   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34599   Dali::Actor *arg2 = 0 ;
34600   Dali::Dimension::Type arg3 ;
34601   float result;
34602
34603   arg1 = (Dali::CustomActorImpl *)jarg1;
34604   arg2 = (Dali::Actor *)jarg2;
34605   if (!arg2) {
34606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34607     return 0;
34608   }
34609   arg3 = (Dali::Dimension::Type)jarg3;
34610   {
34611     try {
34612       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34613     } catch (std::out_of_range& e) {
34614       {
34615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34616       };
34617     } catch (std::exception& e) {
34618       {
34619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34620       };
34621     } catch (...) {
34622       {
34623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34624       };
34625     }
34626   }
34627   jresult = result;
34628   return jresult;
34629 }
34630
34631
34632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34633   float jresult ;
34634   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34635   float arg2 ;
34636   float result;
34637
34638   arg1 = (Dali::CustomActorImpl *)jarg1;
34639   arg2 = (float)jarg2;
34640   {
34641     try {
34642       result = (float)(arg1)->GetHeightForWidth(arg2);
34643     } catch (std::out_of_range& e) {
34644       {
34645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34646       };
34647     } catch (std::exception& e) {
34648       {
34649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34650       };
34651     } catch (...) {
34652       {
34653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34654       };
34655     }
34656   }
34657   jresult = result;
34658   return jresult;
34659 }
34660
34661
34662 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34663   float jresult ;
34664   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34665   float arg2 ;
34666   float result;
34667
34668   arg1 = (Dali::CustomActorImpl *)jarg1;
34669   arg2 = (float)jarg2;
34670   {
34671     try {
34672       result = (float)(arg1)->GetWidthForHeight(arg2);
34673     } catch (std::out_of_range& e) {
34674       {
34675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34676       };
34677     } catch (std::exception& e) {
34678       {
34679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34680       };
34681     } catch (...) {
34682       {
34683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34684       };
34685     }
34686   }
34687   jresult = result;
34688   return jresult;
34689 }
34690
34691
34692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34693   unsigned int jresult ;
34694   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34695   Dali::Dimension::Type arg2 ;
34696   bool result;
34697
34698   arg1 = (Dali::CustomActorImpl *)jarg1;
34699   arg2 = (Dali::Dimension::Type)jarg2;
34700   {
34701     try {
34702       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34703     } catch (std::out_of_range& e) {
34704       {
34705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34706       };
34707     } catch (std::exception& e) {
34708       {
34709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34710       };
34711     } catch (...) {
34712       {
34713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34714       };
34715     }
34716   }
34717   jresult = result;
34718   return jresult;
34719 }
34720
34721
34722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34723   unsigned int jresult ;
34724   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34725   bool result;
34726
34727   arg1 = (Dali::CustomActorImpl *)jarg1;
34728   {
34729     try {
34730       result = (bool)(arg1)->RelayoutDependentOnChildren();
34731     } catch (std::out_of_range& e) {
34732       {
34733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34734       };
34735     } catch (std::exception& e) {
34736       {
34737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34738       };
34739     } catch (...) {
34740       {
34741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34742       };
34743     }
34744   }
34745   jresult = result;
34746   return jresult;
34747 }
34748
34749
34750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34751   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34752   Dali::Dimension::Type arg2 ;
34753
34754   arg1 = (Dali::CustomActorImpl *)jarg1;
34755   arg2 = (Dali::Dimension::Type)jarg2;
34756   {
34757     try {
34758       (arg1)->OnCalculateRelayoutSize(arg2);
34759     } catch (std::out_of_range& e) {
34760       {
34761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34762       };
34763     } catch (std::exception& e) {
34764       {
34765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34766       };
34767     } catch (...) {
34768       {
34769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34770       };
34771     }
34772   }
34773 }
34774
34775
34776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34777   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34778   float arg2 ;
34779   Dali::Dimension::Type arg3 ;
34780
34781   arg1 = (Dali::CustomActorImpl *)jarg1;
34782   arg2 = (float)jarg2;
34783   arg3 = (Dali::Dimension::Type)jarg3;
34784   {
34785     try {
34786       (arg1)->OnLayoutNegotiated(arg2,arg3);
34787     } catch (std::out_of_range& e) {
34788       {
34789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34790       };
34791     } catch (std::exception& e) {
34792       {
34793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34794       };
34795     } catch (...) {
34796       {
34797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34798       };
34799     }
34800   }
34801 }
34802
34803
34804 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34805   unsigned int jresult ;
34806   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34807   bool result;
34808
34809   arg1 = (Dali::CustomActorImpl *)jarg1;
34810   {
34811     try {
34812       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34813     } catch (std::out_of_range& e) {
34814       {
34815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34816       };
34817     } catch (std::exception& e) {
34818       {
34819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34820       };
34821     } catch (...) {
34822       {
34823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34824       };
34825     }
34826   }
34827   jresult = result;
34828   return jresult;
34829 }
34830
34831
34832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34833   unsigned int jresult ;
34834   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34835   bool result;
34836
34837   arg1 = (Dali::CustomActorImpl *)jarg1;
34838   {
34839     try {
34840       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34841     } catch (std::out_of_range& e) {
34842       {
34843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34844       };
34845     } catch (std::exception& e) {
34846       {
34847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34848       };
34849     } catch (...) {
34850       {
34851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34852       };
34853     }
34854   }
34855   jresult = result;
34856   return jresult;
34857 }
34858
34859
34860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34861   unsigned int jresult ;
34862   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34863   bool result;
34864
34865   arg1 = (Dali::CustomActorImpl *)jarg1;
34866   {
34867     try {
34868       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34869     } catch (std::out_of_range& e) {
34870       {
34871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34872       };
34873     } catch (std::exception& e) {
34874       {
34875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34876       };
34877     } catch (...) {
34878       {
34879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34880       };
34881     }
34882   }
34883   jresult = result;
34884   return jresult;
34885 }
34886
34887
34888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34889   unsigned int jresult ;
34890   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34891   bool result;
34892
34893   arg1 = (Dali::CustomActorImpl *)jarg1;
34894   {
34895     try {
34896       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34897     } catch (std::out_of_range& e) {
34898       {
34899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34900       };
34901     } catch (std::exception& e) {
34902       {
34903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34904       };
34905     } catch (...) {
34906       {
34907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34908       };
34909     }
34910   }
34911   jresult = result;
34912   return jresult;
34913 }
34914
34915
34916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
34917   void * jresult ;
34918   Dali::CustomActor *result = 0 ;
34919
34920   {
34921     try {
34922       result = (Dali::CustomActor *)new Dali::CustomActor();
34923     } catch (std::out_of_range& e) {
34924       {
34925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34926       };
34927     } catch (std::exception& e) {
34928       {
34929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34930       };
34931     } catch (...) {
34932       {
34933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34934       };
34935     }
34936   }
34937   jresult = (void *)result;
34938   return jresult;
34939 }
34940
34941
34942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
34943   void * jresult ;
34944   Dali::BaseHandle arg1 ;
34945   Dali::BaseHandle *argp1 ;
34946   Dali::CustomActor result;
34947
34948   argp1 = (Dali::BaseHandle *)jarg1;
34949   if (!argp1) {
34950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34951     return 0;
34952   }
34953   arg1 = *argp1;
34954   {
34955     try {
34956       result = Dali::CustomActor::DownCast(arg1);
34957     } catch (std::out_of_range& e) {
34958       {
34959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34960       };
34961     } catch (std::exception& e) {
34962       {
34963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34964       };
34965     } catch (...) {
34966       {
34967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34968       };
34969     }
34970   }
34971   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34972   return jresult;
34973 }
34974
34975
34976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
34977   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34978
34979   arg1 = (Dali::CustomActor *)jarg1;
34980   {
34981     try {
34982       delete arg1;
34983     } catch (std::out_of_range& e) {
34984       {
34985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34986       };
34987     } catch (std::exception& e) {
34988       {
34989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34990       };
34991     } catch (...) {
34992       {
34993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34994       };
34995     }
34996   }
34997 }
34998
34999
35000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
35001   void * jresult ;
35002   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35003   Dali::CustomActorImpl *result = 0 ;
35004
35005   arg1 = (Dali::CustomActor *)jarg1;
35006   {
35007     try {
35008       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
35009     } catch (std::out_of_range& e) {
35010       {
35011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35012       };
35013     } catch (std::exception& e) {
35014       {
35015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35016       };
35017     } catch (...) {
35018       {
35019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35020       };
35021     }
35022   }
35023   jresult = (void *)result;
35024   return jresult;
35025 }
35026
35027
35028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
35029   void * jresult ;
35030   Dali::CustomActorImpl *arg1 = 0 ;
35031   Dali::CustomActor *result = 0 ;
35032
35033   arg1 = (Dali::CustomActorImpl *)jarg1;
35034   if (!arg1) {
35035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
35036     return 0;
35037   }
35038   {
35039     try {
35040       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
35041     } catch (std::out_of_range& e) {
35042       {
35043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35044       };
35045     } catch (std::exception& e) {
35046       {
35047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35048       };
35049     } catch (...) {
35050       {
35051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35052       };
35053     }
35054   }
35055   jresult = (void *)result;
35056   return jresult;
35057 }
35058
35059
35060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
35061   void * jresult ;
35062   Dali::CustomActor *arg1 = 0 ;
35063   Dali::CustomActor *result = 0 ;
35064
35065   arg1 = (Dali::CustomActor *)jarg1;
35066   if (!arg1) {
35067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35068     return 0;
35069   }
35070   {
35071     try {
35072       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
35073     } catch (std::out_of_range& e) {
35074       {
35075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35076       };
35077     } catch (std::exception& e) {
35078       {
35079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35080       };
35081     } catch (...) {
35082       {
35083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35084       };
35085     }
35086   }
35087   jresult = (void *)result;
35088   return jresult;
35089 }
35090
35091
35092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35093   void * jresult ;
35094   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35095   Dali::CustomActor *arg2 = 0 ;
35096   Dali::CustomActor *result = 0 ;
35097
35098   arg1 = (Dali::CustomActor *)jarg1;
35099   arg2 = (Dali::CustomActor *)jarg2;
35100   if (!arg2) {
35101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35102     return 0;
35103   }
35104   {
35105     try {
35106       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35107     } catch (std::out_of_range& e) {
35108       {
35109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35110       };
35111     } catch (std::exception& e) {
35112       {
35113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35114       };
35115     } catch (...) {
35116       {
35117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35118       };
35119     }
35120   }
35121   jresult = (void *)result;
35122   return jresult;
35123 }
35124
35125
35126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35127   int jresult ;
35128   int result;
35129
35130   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35131   jresult = (int)result;
35132   return jresult;
35133 }
35134
35135
35136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35137   int jresult ;
35138   int result;
35139
35140   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35141   jresult = (int)result;
35142   return jresult;
35143 }
35144
35145
35146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35147   int jresult ;
35148   int result;
35149
35150   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35151   jresult = (int)result;
35152   return jresult;
35153 }
35154
35155
35156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35157   int jresult ;
35158   int result;
35159
35160   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35161   jresult = (int)result;
35162   return jresult;
35163 }
35164
35165
35166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35167   int jresult ;
35168   int result;
35169
35170   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35171   jresult = (int)result;
35172   return jresult;
35173 }
35174
35175
35176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35177   int jresult ;
35178   int result;
35179
35180   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35181   jresult = (int)result;
35182   return jresult;
35183 }
35184
35185
35186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35187   int jresult ;
35188   int result;
35189
35190   result = (int)Dali::PanGestureDetector::Property::PANNING;
35191   jresult = (int)result;
35192   return jresult;
35193 }
35194
35195
35196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35197   void * jresult ;
35198   Dali::PanGestureDetector::Property *result = 0 ;
35199
35200   {
35201     try {
35202       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35203     } catch (std::out_of_range& e) {
35204       {
35205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35206       };
35207     } catch (std::exception& e) {
35208       {
35209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35210       };
35211     } catch (...) {
35212       {
35213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35214       };
35215     }
35216   }
35217   jresult = (void *)result;
35218   return jresult;
35219 }
35220
35221
35222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35223   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35224
35225   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35226   {
35227     try {
35228       delete arg1;
35229     } catch (std::out_of_range& e) {
35230       {
35231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35232       };
35233     } catch (std::exception& e) {
35234       {
35235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35236       };
35237     } catch (...) {
35238       {
35239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35240       };
35241     }
35242   }
35243 }
35244
35245
35246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35247   void * jresult ;
35248   Dali::Radian *result = 0 ;
35249
35250   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35251   jresult = (void *)result;
35252   return jresult;
35253 }
35254
35255
35256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35257   void * jresult ;
35258   Dali::Radian *result = 0 ;
35259
35260   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35261   jresult = (void *)result;
35262   return jresult;
35263 }
35264
35265
35266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35267   void * jresult ;
35268   Dali::Radian *result = 0 ;
35269
35270   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35271   jresult = (void *)result;
35272   return jresult;
35273 }
35274
35275
35276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35277   void * jresult ;
35278   Dali::Radian *result = 0 ;
35279
35280   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35281   jresult = (void *)result;
35282   return jresult;
35283 }
35284
35285
35286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35287   void * jresult ;
35288   Dali::Radian *result = 0 ;
35289
35290   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35291   jresult = (void *)result;
35292   return jresult;
35293 }
35294
35295
35296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35297   void * jresult ;
35298   Dali::Radian *result = 0 ;
35299
35300   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35301   jresult = (void *)result;
35302   return jresult;
35303 }
35304
35305
35306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35307   void * jresult ;
35308   Dali::Radian *result = 0 ;
35309
35310   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35311   jresult = (void *)result;
35312   return jresult;
35313 }
35314
35315
35316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35317   void * jresult ;
35318   Dali::PanGestureDetector *result = 0 ;
35319
35320   {
35321     try {
35322       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35323     } catch (std::out_of_range& e) {
35324       {
35325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35326       };
35327     } catch (std::exception& e) {
35328       {
35329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35330       };
35331     } catch (...) {
35332       {
35333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35334       };
35335     }
35336   }
35337   jresult = (void *)result;
35338   return jresult;
35339 }
35340
35341
35342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35343   void * jresult ;
35344   Dali::PanGestureDetector result;
35345
35346   {
35347     try {
35348       result = Dali::PanGestureDetector::New();
35349     } catch (std::out_of_range& e) {
35350       {
35351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35352       };
35353     } catch (std::exception& e) {
35354       {
35355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35356       };
35357     } catch (...) {
35358       {
35359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35360       };
35361     }
35362   }
35363   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35364   return jresult;
35365 }
35366
35367
35368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35369   void * jresult ;
35370   Dali::BaseHandle arg1 ;
35371   Dali::BaseHandle *argp1 ;
35372   Dali::PanGestureDetector result;
35373
35374   argp1 = (Dali::BaseHandle *)jarg1;
35375   if (!argp1) {
35376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35377     return 0;
35378   }
35379   arg1 = *argp1;
35380   {
35381     try {
35382       result = Dali::PanGestureDetector::DownCast(arg1);
35383     } catch (std::out_of_range& e) {
35384       {
35385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35386       };
35387     } catch (std::exception& e) {
35388       {
35389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35390       };
35391     } catch (...) {
35392       {
35393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35394       };
35395     }
35396   }
35397   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35398   return jresult;
35399 }
35400
35401
35402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35403   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35404
35405   arg1 = (Dali::PanGestureDetector *)jarg1;
35406   {
35407     try {
35408       delete arg1;
35409     } catch (std::out_of_range& e) {
35410       {
35411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35412       };
35413     } catch (std::exception& e) {
35414       {
35415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35416       };
35417     } catch (...) {
35418       {
35419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35420       };
35421     }
35422   }
35423 }
35424
35425
35426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35427   void * jresult ;
35428   Dali::PanGestureDetector *arg1 = 0 ;
35429   Dali::PanGestureDetector *result = 0 ;
35430
35431   arg1 = (Dali::PanGestureDetector *)jarg1;
35432   if (!arg1) {
35433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35434     return 0;
35435   }
35436   {
35437     try {
35438       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35439     } catch (std::out_of_range& e) {
35440       {
35441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35442       };
35443     } catch (std::exception& e) {
35444       {
35445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35446       };
35447     } catch (...) {
35448       {
35449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35450       };
35451     }
35452   }
35453   jresult = (void *)result;
35454   return jresult;
35455 }
35456
35457
35458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35459   void * jresult ;
35460   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35461   Dali::PanGestureDetector *arg2 = 0 ;
35462   Dali::PanGestureDetector *result = 0 ;
35463
35464   arg1 = (Dali::PanGestureDetector *)jarg1;
35465   arg2 = (Dali::PanGestureDetector *)jarg2;
35466   if (!arg2) {
35467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35468     return 0;
35469   }
35470   {
35471     try {
35472       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35473     } catch (std::out_of_range& e) {
35474       {
35475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35476       };
35477     } catch (std::exception& e) {
35478       {
35479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35480       };
35481     } catch (...) {
35482       {
35483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35484       };
35485     }
35486   }
35487   jresult = (void *)result;
35488   return jresult;
35489 }
35490
35491
35492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35493   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35494   unsigned int arg2 ;
35495
35496   arg1 = (Dali::PanGestureDetector *)jarg1;
35497   arg2 = (unsigned int)jarg2;
35498   {
35499     try {
35500       (arg1)->SetMinimumTouchesRequired(arg2);
35501     } catch (std::out_of_range& e) {
35502       {
35503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35504       };
35505     } catch (std::exception& e) {
35506       {
35507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35508       };
35509     } catch (...) {
35510       {
35511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35512       };
35513     }
35514   }
35515 }
35516
35517
35518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35519   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35520   unsigned int arg2 ;
35521
35522   arg1 = (Dali::PanGestureDetector *)jarg1;
35523   arg2 = (unsigned int)jarg2;
35524   {
35525     try {
35526       (arg1)->SetMaximumTouchesRequired(arg2);
35527     } catch (std::out_of_range& e) {
35528       {
35529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35530       };
35531     } catch (std::exception& e) {
35532       {
35533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35534       };
35535     } catch (...) {
35536       {
35537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35538       };
35539     }
35540   }
35541 }
35542
35543
35544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35545   unsigned int jresult ;
35546   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35547   unsigned int result;
35548
35549   arg1 = (Dali::PanGestureDetector *)jarg1;
35550   {
35551     try {
35552       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35553     } catch (std::out_of_range& e) {
35554       {
35555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35556       };
35557     } catch (std::exception& e) {
35558       {
35559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35560       };
35561     } catch (...) {
35562       {
35563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35564       };
35565     }
35566   }
35567   jresult = result;
35568   return jresult;
35569 }
35570
35571
35572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35573   unsigned int jresult ;
35574   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35575   unsigned int result;
35576
35577   arg1 = (Dali::PanGestureDetector *)jarg1;
35578   {
35579     try {
35580       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35581     } catch (std::out_of_range& e) {
35582       {
35583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35584       };
35585     } catch (std::exception& e) {
35586       {
35587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35588       };
35589     } catch (...) {
35590       {
35591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35592       };
35593     }
35594   }
35595   jresult = result;
35596   return jresult;
35597 }
35598
35599
35600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35601   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35602   Dali::Radian arg2 ;
35603   Dali::Radian arg3 ;
35604   Dali::Radian *argp2 ;
35605   Dali::Radian *argp3 ;
35606
35607   arg1 = (Dali::PanGestureDetector *)jarg1;
35608   argp2 = (Dali::Radian *)jarg2;
35609   if (!argp2) {
35610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35611     return ;
35612   }
35613   arg2 = *argp2;
35614   argp3 = (Dali::Radian *)jarg3;
35615   if (!argp3) {
35616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35617     return ;
35618   }
35619   arg3 = *argp3;
35620   {
35621     try {
35622       (arg1)->AddAngle(arg2,arg3);
35623     } catch (std::out_of_range& e) {
35624       {
35625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35626       };
35627     } catch (std::exception& e) {
35628       {
35629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35630       };
35631     } catch (...) {
35632       {
35633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35634       };
35635     }
35636   }
35637 }
35638
35639
35640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35641   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35642   Dali::Radian arg2 ;
35643   Dali::Radian *argp2 ;
35644
35645   arg1 = (Dali::PanGestureDetector *)jarg1;
35646   argp2 = (Dali::Radian *)jarg2;
35647   if (!argp2) {
35648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35649     return ;
35650   }
35651   arg2 = *argp2;
35652   {
35653     try {
35654       (arg1)->AddAngle(arg2);
35655     } catch (std::out_of_range& e) {
35656       {
35657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35658       };
35659     } catch (std::exception& e) {
35660       {
35661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35662       };
35663     } catch (...) {
35664       {
35665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35666       };
35667     }
35668   }
35669 }
35670
35671
35672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35673   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35674   Dali::Radian arg2 ;
35675   Dali::Radian arg3 ;
35676   Dali::Radian *argp2 ;
35677   Dali::Radian *argp3 ;
35678
35679   arg1 = (Dali::PanGestureDetector *)jarg1;
35680   argp2 = (Dali::Radian *)jarg2;
35681   if (!argp2) {
35682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35683     return ;
35684   }
35685   arg2 = *argp2;
35686   argp3 = (Dali::Radian *)jarg3;
35687   if (!argp3) {
35688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35689     return ;
35690   }
35691   arg3 = *argp3;
35692   {
35693     try {
35694       (arg1)->AddDirection(arg2,arg3);
35695     } catch (std::out_of_range& e) {
35696       {
35697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35698       };
35699     } catch (std::exception& e) {
35700       {
35701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35702       };
35703     } catch (...) {
35704       {
35705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35706       };
35707     }
35708   }
35709 }
35710
35711
35712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35713   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35714   Dali::Radian arg2 ;
35715   Dali::Radian *argp2 ;
35716
35717   arg1 = (Dali::PanGestureDetector *)jarg1;
35718   argp2 = (Dali::Radian *)jarg2;
35719   if (!argp2) {
35720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35721     return ;
35722   }
35723   arg2 = *argp2;
35724   {
35725     try {
35726       (arg1)->AddDirection(arg2);
35727     } catch (std::out_of_range& e) {
35728       {
35729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35730       };
35731     } catch (std::exception& e) {
35732       {
35733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35734       };
35735     } catch (...) {
35736       {
35737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35738       };
35739     }
35740   }
35741 }
35742
35743
35744 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35745   unsigned long jresult ;
35746   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35747   size_t result;
35748
35749   arg1 = (Dali::PanGestureDetector *)jarg1;
35750   {
35751     try {
35752       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35753     } catch (std::out_of_range& e) {
35754       {
35755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35756       };
35757     } catch (std::exception& e) {
35758       {
35759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35760       };
35761     } catch (...) {
35762       {
35763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35764       };
35765     }
35766   }
35767   jresult = (unsigned long)result;
35768   return jresult;
35769 }
35770
35771
35772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35773   void * jresult ;
35774   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35775   size_t arg2 ;
35776   Dali::PanGestureDetector::AngleThresholdPair result;
35777
35778   arg1 = (Dali::PanGestureDetector *)jarg1;
35779   arg2 = (size_t)jarg2;
35780   {
35781     try {
35782       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35783     } catch (std::out_of_range& e) {
35784       {
35785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35786       };
35787     } catch (std::exception& e) {
35788       {
35789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35790       };
35791     } catch (...) {
35792       {
35793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35794       };
35795     }
35796   }
35797   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35798   return jresult;
35799 }
35800
35801
35802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35803   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35804
35805   arg1 = (Dali::PanGestureDetector *)jarg1;
35806   {
35807     try {
35808       (arg1)->ClearAngles();
35809     } catch (std::out_of_range& e) {
35810       {
35811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35812       };
35813     } catch (std::exception& e) {
35814       {
35815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35816       };
35817     } catch (...) {
35818       {
35819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35820       };
35821     }
35822   }
35823 }
35824
35825
35826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35827   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35828   Dali::Radian arg2 ;
35829   Dali::Radian *argp2 ;
35830
35831   arg1 = (Dali::PanGestureDetector *)jarg1;
35832   argp2 = (Dali::Radian *)jarg2;
35833   if (!argp2) {
35834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35835     return ;
35836   }
35837   arg2 = *argp2;
35838   {
35839     try {
35840       (arg1)->RemoveAngle(arg2);
35841     } catch (std::out_of_range& e) {
35842       {
35843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35844       };
35845     } catch (std::exception& e) {
35846       {
35847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35848       };
35849     } catch (...) {
35850       {
35851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35852       };
35853     }
35854   }
35855 }
35856
35857
35858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35859   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35860   Dali::Radian arg2 ;
35861   Dali::Radian *argp2 ;
35862
35863   arg1 = (Dali::PanGestureDetector *)jarg1;
35864   argp2 = (Dali::Radian *)jarg2;
35865   if (!argp2) {
35866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35867     return ;
35868   }
35869   arg2 = *argp2;
35870   {
35871     try {
35872       (arg1)->RemoveDirection(arg2);
35873     } catch (std::out_of_range& e) {
35874       {
35875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35876       };
35877     } catch (std::exception& e) {
35878       {
35879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35880       };
35881     } catch (...) {
35882       {
35883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35884       };
35885     }
35886   }
35887 }
35888
35889
35890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35891   void * jresult ;
35892   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35893   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35894
35895   arg1 = (Dali::PanGestureDetector *)jarg1;
35896   {
35897     try {
35898       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
35899     } catch (std::out_of_range& e) {
35900       {
35901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35902       };
35903     } catch (std::exception& e) {
35904       {
35905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35906       };
35907     } catch (...) {
35908       {
35909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35910       };
35911     }
35912   }
35913   jresult = (void *)result;
35914   return jresult;
35915 }
35916
35917
35918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
35919   Dali::PanGesture *arg1 = 0 ;
35920
35921   arg1 = (Dali::PanGesture *)jarg1;
35922   if (!arg1) {
35923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35924     return ;
35925   }
35926   {
35927     try {
35928       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
35929     } catch (std::out_of_range& e) {
35930       {
35931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35932       };
35933     } catch (std::exception& e) {
35934       {
35935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35936       };
35937     } catch (...) {
35938       {
35939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35940       };
35941     }
35942   }
35943 }
35944
35945
35946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
35947   void * jresult ;
35948   Dali::PanGesture *result = 0 ;
35949
35950   {
35951     try {
35952       result = (Dali::PanGesture *)new Dali::PanGesture();
35953     } catch (std::out_of_range& e) {
35954       {
35955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35956       };
35957     } catch (std::exception& e) {
35958       {
35959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35960       };
35961     } catch (...) {
35962       {
35963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35964       };
35965     }
35966   }
35967   jresult = (void *)result;
35968   return jresult;
35969 }
35970
35971
35972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
35973   void * jresult ;
35974   Dali::Gesture::State arg1 ;
35975   Dali::PanGesture *result = 0 ;
35976
35977   arg1 = (Dali::Gesture::State)jarg1;
35978   {
35979     try {
35980       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
35981     } catch (std::out_of_range& e) {
35982       {
35983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35984       };
35985     } catch (std::exception& e) {
35986       {
35987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35988       };
35989     } catch (...) {
35990       {
35991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35992       };
35993     }
35994   }
35995   jresult = (void *)result;
35996   return jresult;
35997 }
35998
35999
36000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
36001   void * jresult ;
36002   Dali::PanGesture *arg1 = 0 ;
36003   Dali::PanGesture *result = 0 ;
36004
36005   arg1 = (Dali::PanGesture *)jarg1;
36006   if (!arg1) {
36007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36008     return 0;
36009   }
36010   {
36011     try {
36012       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
36013     } catch (std::out_of_range& e) {
36014       {
36015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36016       };
36017     } catch (std::exception& e) {
36018       {
36019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36020       };
36021     } catch (...) {
36022       {
36023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36024       };
36025     }
36026   }
36027   jresult = (void *)result;
36028   return jresult;
36029 }
36030
36031
36032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
36033   void * jresult ;
36034   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36035   Dali::PanGesture *arg2 = 0 ;
36036   Dali::PanGesture *result = 0 ;
36037
36038   arg1 = (Dali::PanGesture *)jarg1;
36039   arg2 = (Dali::PanGesture *)jarg2;
36040   if (!arg2) {
36041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36042     return 0;
36043   }
36044   {
36045     try {
36046       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
36047     } catch (std::out_of_range& e) {
36048       {
36049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36050       };
36051     } catch (std::exception& e) {
36052       {
36053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36054       };
36055     } catch (...) {
36056       {
36057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36058       };
36059     }
36060   }
36061   jresult = (void *)result;
36062   return jresult;
36063 }
36064
36065
36066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
36067   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36068
36069   arg1 = (Dali::PanGesture *)jarg1;
36070   {
36071     try {
36072       delete arg1;
36073     } catch (std::out_of_range& e) {
36074       {
36075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36076       };
36077     } catch (std::exception& e) {
36078       {
36079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36080       };
36081     } catch (...) {
36082       {
36083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36084       };
36085     }
36086   }
36087 }
36088
36089
36090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36091   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36092   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36093
36094   arg1 = (Dali::PanGesture *)jarg1;
36095   arg2 = (Dali::Vector2 *)jarg2;
36096   if (arg1) (arg1)->velocity = *arg2;
36097 }
36098
36099
36100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36101   void * jresult ;
36102   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36103   Dali::Vector2 *result = 0 ;
36104
36105   arg1 = (Dali::PanGesture *)jarg1;
36106   result = (Dali::Vector2 *)& ((arg1)->velocity);
36107   jresult = (void *)result;
36108   return jresult;
36109 }
36110
36111
36112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36113   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36114   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36115
36116   arg1 = (Dali::PanGesture *)jarg1;
36117   arg2 = (Dali::Vector2 *)jarg2;
36118   if (arg1) (arg1)->displacement = *arg2;
36119 }
36120
36121
36122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36123   void * jresult ;
36124   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36125   Dali::Vector2 *result = 0 ;
36126
36127   arg1 = (Dali::PanGesture *)jarg1;
36128   result = (Dali::Vector2 *)& ((arg1)->displacement);
36129   jresult = (void *)result;
36130   return jresult;
36131 }
36132
36133
36134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36135   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36136   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36137
36138   arg1 = (Dali::PanGesture *)jarg1;
36139   arg2 = (Dali::Vector2 *)jarg2;
36140   if (arg1) (arg1)->position = *arg2;
36141 }
36142
36143
36144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36145   void * jresult ;
36146   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36147   Dali::Vector2 *result = 0 ;
36148
36149   arg1 = (Dali::PanGesture *)jarg1;
36150   result = (Dali::Vector2 *)& ((arg1)->position);
36151   jresult = (void *)result;
36152   return jresult;
36153 }
36154
36155
36156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36157   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36158   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36159
36160   arg1 = (Dali::PanGesture *)jarg1;
36161   arg2 = (Dali::Vector2 *)jarg2;
36162   if (arg1) (arg1)->screenVelocity = *arg2;
36163 }
36164
36165
36166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36167   void * jresult ;
36168   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36169   Dali::Vector2 *result = 0 ;
36170
36171   arg1 = (Dali::PanGesture *)jarg1;
36172   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36173   jresult = (void *)result;
36174   return jresult;
36175 }
36176
36177
36178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36179   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36180   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36181
36182   arg1 = (Dali::PanGesture *)jarg1;
36183   arg2 = (Dali::Vector2 *)jarg2;
36184   if (arg1) (arg1)->screenDisplacement = *arg2;
36185 }
36186
36187
36188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36189   void * jresult ;
36190   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36191   Dali::Vector2 *result = 0 ;
36192
36193   arg1 = (Dali::PanGesture *)jarg1;
36194   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36195   jresult = (void *)result;
36196   return jresult;
36197 }
36198
36199
36200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36201   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36202   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36203
36204   arg1 = (Dali::PanGesture *)jarg1;
36205   arg2 = (Dali::Vector2 *)jarg2;
36206   if (arg1) (arg1)->screenPosition = *arg2;
36207 }
36208
36209
36210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36211   void * jresult ;
36212   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36213   Dali::Vector2 *result = 0 ;
36214
36215   arg1 = (Dali::PanGesture *)jarg1;
36216   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36217   jresult = (void *)result;
36218   return jresult;
36219 }
36220
36221
36222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36223   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36224   unsigned int arg2 ;
36225
36226   arg1 = (Dali::PanGesture *)jarg1;
36227   arg2 = (unsigned int)jarg2;
36228   if (arg1) (arg1)->numberOfTouches = arg2;
36229 }
36230
36231
36232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36233   unsigned int jresult ;
36234   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36235   unsigned int result;
36236
36237   arg1 = (Dali::PanGesture *)jarg1;
36238   result = (unsigned int) ((arg1)->numberOfTouches);
36239   jresult = result;
36240   return jresult;
36241 }
36242
36243
36244 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36245   float jresult ;
36246   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36247   float result;
36248
36249   arg1 = (Dali::PanGesture *)jarg1;
36250   {
36251     try {
36252       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36253     } catch (std::out_of_range& e) {
36254       {
36255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36256       };
36257     } catch (std::exception& e) {
36258       {
36259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36260       };
36261     } catch (...) {
36262       {
36263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36264       };
36265     }
36266   }
36267   jresult = result;
36268   return jresult;
36269 }
36270
36271
36272 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36273   float jresult ;
36274   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36275   float result;
36276
36277   arg1 = (Dali::PanGesture *)jarg1;
36278   {
36279     try {
36280       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36281     } catch (std::out_of_range& e) {
36282       {
36283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36284       };
36285     } catch (std::exception& e) {
36286       {
36287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36288       };
36289     } catch (...) {
36290       {
36291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36292       };
36293     }
36294   }
36295   jresult = result;
36296   return jresult;
36297 }
36298
36299
36300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36301   float jresult ;
36302   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36303   float result;
36304
36305   arg1 = (Dali::PanGesture *)jarg1;
36306   {
36307     try {
36308       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36309     } catch (std::out_of_range& e) {
36310       {
36311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36312       };
36313     } catch (std::exception& e) {
36314       {
36315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36316       };
36317     } catch (...) {
36318       {
36319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36320       };
36321     }
36322   }
36323   jresult = result;
36324   return jresult;
36325 }
36326
36327
36328 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36329   float jresult ;
36330   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36331   float result;
36332
36333   arg1 = (Dali::PanGesture *)jarg1;
36334   {
36335     try {
36336       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36337     } catch (std::out_of_range& e) {
36338       {
36339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36340       };
36341     } catch (std::exception& e) {
36342       {
36343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36344       };
36345     } catch (...) {
36346       {
36347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36348       };
36349     }
36350   }
36351   jresult = result;
36352   return jresult;
36353 }
36354
36355
36356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36357   void * jresult ;
36358   Dali::PinchGestureDetector *result = 0 ;
36359
36360   {
36361     try {
36362       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36363     } catch (std::out_of_range& e) {
36364       {
36365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36366       };
36367     } catch (std::exception& e) {
36368       {
36369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36370       };
36371     } catch (...) {
36372       {
36373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36374       };
36375     }
36376   }
36377   jresult = (void *)result;
36378   return jresult;
36379 }
36380
36381
36382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36383   void * jresult ;
36384   Dali::PinchGestureDetector result;
36385
36386   {
36387     try {
36388       result = Dali::PinchGestureDetector::New();
36389     } catch (std::out_of_range& e) {
36390       {
36391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36392       };
36393     } catch (std::exception& e) {
36394       {
36395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36396       };
36397     } catch (...) {
36398       {
36399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36400       };
36401     }
36402   }
36403   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36404   return jresult;
36405 }
36406
36407
36408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36409   void * jresult ;
36410   Dali::BaseHandle arg1 ;
36411   Dali::BaseHandle *argp1 ;
36412   Dali::PinchGestureDetector result;
36413
36414   argp1 = (Dali::BaseHandle *)jarg1;
36415   if (!argp1) {
36416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36417     return 0;
36418   }
36419   arg1 = *argp1;
36420   {
36421     try {
36422       result = Dali::PinchGestureDetector::DownCast(arg1);
36423     } catch (std::out_of_range& e) {
36424       {
36425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36426       };
36427     } catch (std::exception& e) {
36428       {
36429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36430       };
36431     } catch (...) {
36432       {
36433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36434       };
36435     }
36436   }
36437   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36438   return jresult;
36439 }
36440
36441
36442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36443   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36444
36445   arg1 = (Dali::PinchGestureDetector *)jarg1;
36446   {
36447     try {
36448       delete arg1;
36449     } catch (std::out_of_range& e) {
36450       {
36451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36452       };
36453     } catch (std::exception& e) {
36454       {
36455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36456       };
36457     } catch (...) {
36458       {
36459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36460       };
36461     }
36462   }
36463 }
36464
36465
36466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36467   void * jresult ;
36468   Dali::PinchGestureDetector *arg1 = 0 ;
36469   Dali::PinchGestureDetector *result = 0 ;
36470
36471   arg1 = (Dali::PinchGestureDetector *)jarg1;
36472   if (!arg1) {
36473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36474     return 0;
36475   }
36476   {
36477     try {
36478       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36479     } catch (std::out_of_range& e) {
36480       {
36481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36482       };
36483     } catch (std::exception& e) {
36484       {
36485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36486       };
36487     } catch (...) {
36488       {
36489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36490       };
36491     }
36492   }
36493   jresult = (void *)result;
36494   return jresult;
36495 }
36496
36497
36498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36499   void * jresult ;
36500   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36501   Dali::PinchGestureDetector *arg2 = 0 ;
36502   Dali::PinchGestureDetector *result = 0 ;
36503
36504   arg1 = (Dali::PinchGestureDetector *)jarg1;
36505   arg2 = (Dali::PinchGestureDetector *)jarg2;
36506   if (!arg2) {
36507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36508     return 0;
36509   }
36510   {
36511     try {
36512       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36513     } catch (std::out_of_range& e) {
36514       {
36515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36516       };
36517     } catch (std::exception& e) {
36518       {
36519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36520       };
36521     } catch (...) {
36522       {
36523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36524       };
36525     }
36526   }
36527   jresult = (void *)result;
36528   return jresult;
36529 }
36530
36531
36532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36533   void * jresult ;
36534   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36535   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36536
36537   arg1 = (Dali::PinchGestureDetector *)jarg1;
36538   {
36539     try {
36540       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36541     } catch (std::out_of_range& e) {
36542       {
36543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36544       };
36545     } catch (std::exception& e) {
36546       {
36547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36548       };
36549     } catch (...) {
36550       {
36551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36552       };
36553     }
36554   }
36555   jresult = (void *)result;
36556   return jresult;
36557 }
36558
36559
36560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36561   void * jresult ;
36562   Dali::Gesture::State arg1 ;
36563   Dali::PinchGesture *result = 0 ;
36564
36565   arg1 = (Dali::Gesture::State)jarg1;
36566   {
36567     try {
36568       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36569     } catch (std::out_of_range& e) {
36570       {
36571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36572       };
36573     } catch (std::exception& e) {
36574       {
36575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36576       };
36577     } catch (...) {
36578       {
36579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36580       };
36581     }
36582   }
36583   jresult = (void *)result;
36584   return jresult;
36585 }
36586
36587
36588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36589   void * jresult ;
36590   Dali::PinchGesture *arg1 = 0 ;
36591   Dali::PinchGesture *result = 0 ;
36592
36593   arg1 = (Dali::PinchGesture *)jarg1;
36594   if (!arg1) {
36595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36596     return 0;
36597   }
36598   {
36599     try {
36600       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36601     } catch (std::out_of_range& e) {
36602       {
36603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36604       };
36605     } catch (std::exception& e) {
36606       {
36607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36608       };
36609     } catch (...) {
36610       {
36611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36612       };
36613     }
36614   }
36615   jresult = (void *)result;
36616   return jresult;
36617 }
36618
36619
36620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36621   void * jresult ;
36622   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36623   Dali::PinchGesture *arg2 = 0 ;
36624   Dali::PinchGesture *result = 0 ;
36625
36626   arg1 = (Dali::PinchGesture *)jarg1;
36627   arg2 = (Dali::PinchGesture *)jarg2;
36628   if (!arg2) {
36629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36630     return 0;
36631   }
36632   {
36633     try {
36634       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36635     } catch (std::out_of_range& e) {
36636       {
36637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36638       };
36639     } catch (std::exception& e) {
36640       {
36641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36642       };
36643     } catch (...) {
36644       {
36645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36646       };
36647     }
36648   }
36649   jresult = (void *)result;
36650   return jresult;
36651 }
36652
36653
36654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36655   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36656
36657   arg1 = (Dali::PinchGesture *)jarg1;
36658   {
36659     try {
36660       delete arg1;
36661     } catch (std::out_of_range& e) {
36662       {
36663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36664       };
36665     } catch (std::exception& e) {
36666       {
36667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36668       };
36669     } catch (...) {
36670       {
36671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36672       };
36673     }
36674   }
36675 }
36676
36677
36678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36679   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36680   float arg2 ;
36681
36682   arg1 = (Dali::PinchGesture *)jarg1;
36683   arg2 = (float)jarg2;
36684   if (arg1) (arg1)->scale = arg2;
36685 }
36686
36687
36688 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36689   float jresult ;
36690   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36691   float result;
36692
36693   arg1 = (Dali::PinchGesture *)jarg1;
36694   result = (float) ((arg1)->scale);
36695   jresult = result;
36696   return jresult;
36697 }
36698
36699
36700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36701   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36702   float arg2 ;
36703
36704   arg1 = (Dali::PinchGesture *)jarg1;
36705   arg2 = (float)jarg2;
36706   if (arg1) (arg1)->speed = arg2;
36707 }
36708
36709
36710 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36711   float jresult ;
36712   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36713   float result;
36714
36715   arg1 = (Dali::PinchGesture *)jarg1;
36716   result = (float) ((arg1)->speed);
36717   jresult = result;
36718   return jresult;
36719 }
36720
36721
36722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36723   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36724   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36725
36726   arg1 = (Dali::PinchGesture *)jarg1;
36727   arg2 = (Dali::Vector2 *)jarg2;
36728   if (arg1) (arg1)->screenCenterPoint = *arg2;
36729 }
36730
36731
36732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36733   void * jresult ;
36734   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36735   Dali::Vector2 *result = 0 ;
36736
36737   arg1 = (Dali::PinchGesture *)jarg1;
36738   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36739   jresult = (void *)result;
36740   return jresult;
36741 }
36742
36743
36744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36745   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36746   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36747
36748   arg1 = (Dali::PinchGesture *)jarg1;
36749   arg2 = (Dali::Vector2 *)jarg2;
36750   if (arg1) (arg1)->localCenterPoint = *arg2;
36751 }
36752
36753
36754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36755   void * jresult ;
36756   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36757   Dali::Vector2 *result = 0 ;
36758
36759   arg1 = (Dali::PinchGesture *)jarg1;
36760   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36761   jresult = (void *)result;
36762   return jresult;
36763 }
36764
36765
36766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36767   void * jresult ;
36768   Dali::TapGestureDetector *result = 0 ;
36769
36770   {
36771     try {
36772       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36773     } catch (std::out_of_range& e) {
36774       {
36775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36776       };
36777     } catch (std::exception& e) {
36778       {
36779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36780       };
36781     } catch (...) {
36782       {
36783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36784       };
36785     }
36786   }
36787   jresult = (void *)result;
36788   return jresult;
36789 }
36790
36791
36792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36793   void * jresult ;
36794   Dali::TapGestureDetector result;
36795
36796   {
36797     try {
36798       result = Dali::TapGestureDetector::New();
36799     } catch (std::out_of_range& e) {
36800       {
36801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36802       };
36803     } catch (std::exception& e) {
36804       {
36805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36806       };
36807     } catch (...) {
36808       {
36809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36810       };
36811     }
36812   }
36813   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36814   return jresult;
36815 }
36816
36817
36818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36819   void * jresult ;
36820   unsigned int arg1 ;
36821   Dali::TapGestureDetector result;
36822
36823   arg1 = (unsigned int)jarg1;
36824   {
36825     try {
36826       result = Dali::TapGestureDetector::New(arg1);
36827     } catch (std::out_of_range& e) {
36828       {
36829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36830       };
36831     } catch (std::exception& e) {
36832       {
36833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36834       };
36835     } catch (...) {
36836       {
36837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36838       };
36839     }
36840   }
36841   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36842   return jresult;
36843 }
36844
36845
36846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36847   void * jresult ;
36848   Dali::BaseHandle arg1 ;
36849   Dali::BaseHandle *argp1 ;
36850   Dali::TapGestureDetector result;
36851
36852   argp1 = (Dali::BaseHandle *)jarg1;
36853   if (!argp1) {
36854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36855     return 0;
36856   }
36857   arg1 = *argp1;
36858   {
36859     try {
36860       result = Dali::TapGestureDetector::DownCast(arg1);
36861     } catch (std::out_of_range& e) {
36862       {
36863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36864       };
36865     } catch (std::exception& e) {
36866       {
36867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36868       };
36869     } catch (...) {
36870       {
36871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36872       };
36873     }
36874   }
36875   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36876   return jresult;
36877 }
36878
36879
36880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36881   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36882
36883   arg1 = (Dali::TapGestureDetector *)jarg1;
36884   {
36885     try {
36886       delete arg1;
36887     } catch (std::out_of_range& e) {
36888       {
36889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36890       };
36891     } catch (std::exception& e) {
36892       {
36893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36894       };
36895     } catch (...) {
36896       {
36897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36898       };
36899     }
36900   }
36901 }
36902
36903
36904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
36905   void * jresult ;
36906   Dali::TapGestureDetector *arg1 = 0 ;
36907   Dali::TapGestureDetector *result = 0 ;
36908
36909   arg1 = (Dali::TapGestureDetector *)jarg1;
36910   if (!arg1) {
36911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36912     return 0;
36913   }
36914   {
36915     try {
36916       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
36917     } catch (std::out_of_range& e) {
36918       {
36919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36920       };
36921     } catch (std::exception& e) {
36922       {
36923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36924       };
36925     } catch (...) {
36926       {
36927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36928       };
36929     }
36930   }
36931   jresult = (void *)result;
36932   return jresult;
36933 }
36934
36935
36936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
36937   void * jresult ;
36938   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36939   Dali::TapGestureDetector *arg2 = 0 ;
36940   Dali::TapGestureDetector *result = 0 ;
36941
36942   arg1 = (Dali::TapGestureDetector *)jarg1;
36943   arg2 = (Dali::TapGestureDetector *)jarg2;
36944   if (!arg2) {
36945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36946     return 0;
36947   }
36948   {
36949     try {
36950       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
36951     } catch (std::out_of_range& e) {
36952       {
36953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36954       };
36955     } catch (std::exception& e) {
36956       {
36957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36958       };
36959     } catch (...) {
36960       {
36961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36962       };
36963     }
36964   }
36965   jresult = (void *)result;
36966   return jresult;
36967 }
36968
36969
36970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
36971   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36972   unsigned int arg2 ;
36973
36974   arg1 = (Dali::TapGestureDetector *)jarg1;
36975   arg2 = (unsigned int)jarg2;
36976   {
36977     try {
36978       (arg1)->SetMinimumTapsRequired(arg2);
36979     } catch (std::out_of_range& e) {
36980       {
36981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36982       };
36983     } catch (std::exception& e) {
36984       {
36985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36986       };
36987     } catch (...) {
36988       {
36989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36990       };
36991     }
36992   }
36993 }
36994
36995
36996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
36997   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36998   unsigned int arg2 ;
36999
37000   arg1 = (Dali::TapGestureDetector *)jarg1;
37001   arg2 = (unsigned int)jarg2;
37002   {
37003     try {
37004       (arg1)->SetMaximumTapsRequired(arg2);
37005     } catch (std::out_of_range& e) {
37006       {
37007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37008       };
37009     } catch (std::exception& e) {
37010       {
37011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37012       };
37013     } catch (...) {
37014       {
37015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37016       };
37017     }
37018   }
37019 }
37020
37021
37022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
37023   unsigned int jresult ;
37024   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37025   unsigned int result;
37026
37027   arg1 = (Dali::TapGestureDetector *)jarg1;
37028   {
37029     try {
37030       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
37031     } catch (std::out_of_range& e) {
37032       {
37033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37034       };
37035     } catch (std::exception& e) {
37036       {
37037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37038       };
37039     } catch (...) {
37040       {
37041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37042       };
37043     }
37044   }
37045   jresult = result;
37046   return jresult;
37047 }
37048
37049
37050 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
37051   unsigned int jresult ;
37052   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37053   unsigned int result;
37054
37055   arg1 = (Dali::TapGestureDetector *)jarg1;
37056   {
37057     try {
37058       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
37059     } catch (std::out_of_range& e) {
37060       {
37061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37062       };
37063     } catch (std::exception& e) {
37064       {
37065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37066       };
37067     } catch (...) {
37068       {
37069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37070       };
37071     }
37072   }
37073   jresult = result;
37074   return jresult;
37075 }
37076
37077
37078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
37079   void * jresult ;
37080   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37081   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37082
37083   arg1 = (Dali::TapGestureDetector *)jarg1;
37084   {
37085     try {
37086       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37087     } catch (std::out_of_range& e) {
37088       {
37089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37090       };
37091     } catch (std::exception& e) {
37092       {
37093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37094       };
37095     } catch (...) {
37096       {
37097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37098       };
37099     }
37100   }
37101   jresult = (void *)result;
37102   return jresult;
37103 }
37104
37105
37106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37107   void * jresult ;
37108   Dali::TapGesture *result = 0 ;
37109
37110   {
37111     try {
37112       result = (Dali::TapGesture *)new Dali::TapGesture();
37113     } catch (std::out_of_range& e) {
37114       {
37115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37116       };
37117     } catch (std::exception& e) {
37118       {
37119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37120       };
37121     } catch (...) {
37122       {
37123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37124       };
37125     }
37126   }
37127   jresult = (void *)result;
37128   return jresult;
37129 }
37130
37131
37132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37133   void * jresult ;
37134   Dali::TapGesture *arg1 = 0 ;
37135   Dali::TapGesture *result = 0 ;
37136
37137   arg1 = (Dali::TapGesture *)jarg1;
37138   if (!arg1) {
37139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37140     return 0;
37141   }
37142   {
37143     try {
37144       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37145     } catch (std::out_of_range& e) {
37146       {
37147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37148       };
37149     } catch (std::exception& e) {
37150       {
37151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37152       };
37153     } catch (...) {
37154       {
37155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37156       };
37157     }
37158   }
37159   jresult = (void *)result;
37160   return jresult;
37161 }
37162
37163
37164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37165   void * jresult ;
37166   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37167   Dali::TapGesture *arg2 = 0 ;
37168   Dali::TapGesture *result = 0 ;
37169
37170   arg1 = (Dali::TapGesture *)jarg1;
37171   arg2 = (Dali::TapGesture *)jarg2;
37172   if (!arg2) {
37173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37174     return 0;
37175   }
37176   {
37177     try {
37178       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37179     } catch (std::out_of_range& e) {
37180       {
37181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37182       };
37183     } catch (std::exception& e) {
37184       {
37185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37186       };
37187     } catch (...) {
37188       {
37189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37190       };
37191     }
37192   }
37193   jresult = (void *)result;
37194   return jresult;
37195 }
37196
37197
37198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37199   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37200
37201   arg1 = (Dali::TapGesture *)jarg1;
37202   {
37203     try {
37204       delete arg1;
37205     } catch (std::out_of_range& e) {
37206       {
37207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37208       };
37209     } catch (std::exception& e) {
37210       {
37211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37212       };
37213     } catch (...) {
37214       {
37215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37216       };
37217     }
37218   }
37219 }
37220
37221
37222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37223   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37224   unsigned int arg2 ;
37225
37226   arg1 = (Dali::TapGesture *)jarg1;
37227   arg2 = (unsigned int)jarg2;
37228   if (arg1) (arg1)->numberOfTaps = arg2;
37229 }
37230
37231
37232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37233   unsigned int jresult ;
37234   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37235   unsigned int result;
37236
37237   arg1 = (Dali::TapGesture *)jarg1;
37238   result = (unsigned int) ((arg1)->numberOfTaps);
37239   jresult = result;
37240   return jresult;
37241 }
37242
37243
37244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37245   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37246   unsigned int arg2 ;
37247
37248   arg1 = (Dali::TapGesture *)jarg1;
37249   arg2 = (unsigned int)jarg2;
37250   if (arg1) (arg1)->numberOfTouches = arg2;
37251 }
37252
37253
37254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37255   unsigned int jresult ;
37256   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37257   unsigned int result;
37258
37259   arg1 = (Dali::TapGesture *)jarg1;
37260   result = (unsigned int) ((arg1)->numberOfTouches);
37261   jresult = result;
37262   return jresult;
37263 }
37264
37265
37266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37267   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37268   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37269
37270   arg1 = (Dali::TapGesture *)jarg1;
37271   arg2 = (Dali::Vector2 *)jarg2;
37272   if (arg1) (arg1)->screenPoint = *arg2;
37273 }
37274
37275
37276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37277   void * jresult ;
37278   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37279   Dali::Vector2 *result = 0 ;
37280
37281   arg1 = (Dali::TapGesture *)jarg1;
37282   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37283   jresult = (void *)result;
37284   return jresult;
37285 }
37286
37287
37288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37289   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37290   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37291
37292   arg1 = (Dali::TapGesture *)jarg1;
37293   arg2 = (Dali::Vector2 *)jarg2;
37294   if (arg1) (arg1)->localPoint = *arg2;
37295 }
37296
37297
37298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37299   void * jresult ;
37300   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37301   Dali::Vector2 *result = 0 ;
37302
37303   arg1 = (Dali::TapGesture *)jarg1;
37304   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37305   jresult = (void *)result;
37306   return jresult;
37307 }
37308
37309
37310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37311   void * jresult ;
37312   Dali::AlphaFunction *result = 0 ;
37313
37314   {
37315     try {
37316       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37317     } catch (std::out_of_range& e) {
37318       {
37319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37320       };
37321     } catch (std::exception& e) {
37322       {
37323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37324       };
37325     } catch (...) {
37326       {
37327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37328       };
37329     }
37330   }
37331   jresult = (void *)result;
37332   return jresult;
37333 }
37334
37335
37336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37337   void * jresult ;
37338   Dali::AlphaFunction::BuiltinFunction arg1 ;
37339   Dali::AlphaFunction *result = 0 ;
37340
37341   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37342   {
37343     try {
37344       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37345     } catch (std::out_of_range& e) {
37346       {
37347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37348       };
37349     } catch (std::exception& e) {
37350       {
37351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37352       };
37353     } catch (...) {
37354       {
37355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37356       };
37357     }
37358   }
37359   jresult = (void *)result;
37360   return jresult;
37361 }
37362
37363
37364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37365   void * jresult ;
37366   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37367   Dali::AlphaFunction *result = 0 ;
37368
37369   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37370   {
37371     try {
37372       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37373     } catch (std::out_of_range& e) {
37374       {
37375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37376       };
37377     } catch (std::exception& e) {
37378       {
37379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37380       };
37381     } catch (...) {
37382       {
37383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37384       };
37385     }
37386   }
37387   jresult = (void *)result;
37388   return jresult;
37389 }
37390
37391
37392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37393   void * jresult ;
37394   Dali::Vector2 *arg1 = 0 ;
37395   Dali::Vector2 *arg2 = 0 ;
37396   Dali::AlphaFunction *result = 0 ;
37397
37398   arg1 = (Dali::Vector2 *)jarg1;
37399   if (!arg1) {
37400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37401     return 0;
37402   }
37403   arg2 = (Dali::Vector2 *)jarg2;
37404   if (!arg2) {
37405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37406     return 0;
37407   }
37408   {
37409     try {
37410       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37411     } catch (std::out_of_range& e) {
37412       {
37413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37414       };
37415     } catch (std::exception& e) {
37416       {
37417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37418       };
37419     } catch (...) {
37420       {
37421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37422       };
37423     }
37424   }
37425   jresult = (void *)result;
37426   return jresult;
37427 }
37428
37429
37430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37431   void * jresult ;
37432   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37433   Dali::Vector4 result;
37434
37435   arg1 = (Dali::AlphaFunction *)jarg1;
37436   {
37437     try {
37438       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37439     } catch (std::out_of_range& e) {
37440       {
37441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37442       };
37443     } catch (std::exception& e) {
37444       {
37445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37446       };
37447     } catch (...) {
37448       {
37449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37450       };
37451     }
37452   }
37453   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37454   return jresult;
37455 }
37456
37457
37458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37459   void * jresult ;
37460   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37461   Dali::AlphaFunctionPrototype result;
37462
37463   arg1 = (Dali::AlphaFunction *)jarg1;
37464   {
37465     try {
37466       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37467     } catch (std::out_of_range& e) {
37468       {
37469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37470       };
37471     } catch (std::exception& e) {
37472       {
37473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37474       };
37475     } catch (...) {
37476       {
37477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37478       };
37479     }
37480   }
37481   jresult = (void *)result;
37482   return jresult;
37483 }
37484
37485
37486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37487   int jresult ;
37488   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37489   Dali::AlphaFunction::BuiltinFunction result;
37490
37491   arg1 = (Dali::AlphaFunction *)jarg1;
37492   {
37493     try {
37494       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37495     } catch (std::out_of_range& e) {
37496       {
37497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37498       };
37499     } catch (std::exception& e) {
37500       {
37501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37502       };
37503     } catch (...) {
37504       {
37505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37506       };
37507     }
37508   }
37509   jresult = (int)result;
37510   return jresult;
37511 }
37512
37513
37514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37515   int jresult ;
37516   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37517   Dali::AlphaFunction::Mode result;
37518
37519   arg1 = (Dali::AlphaFunction *)jarg1;
37520   {
37521     try {
37522       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37523     } catch (std::out_of_range& e) {
37524       {
37525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37526       };
37527     } catch (std::exception& e) {
37528       {
37529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37530       };
37531     } catch (...) {
37532       {
37533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37534       };
37535     }
37536   }
37537   jresult = (int)result;
37538   return jresult;
37539 }
37540
37541
37542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37543   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37544
37545   arg1 = (Dali::AlphaFunction *)jarg1;
37546   {
37547     try {
37548       delete arg1;
37549     } catch (std::out_of_range& e) {
37550       {
37551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37552       };
37553     } catch (std::exception& e) {
37554       {
37555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37556       };
37557     } catch (...) {
37558       {
37559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37560       };
37561     }
37562   }
37563 }
37564
37565
37566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37567   void * jresult ;
37568   Dali::KeyFrames result;
37569
37570   {
37571     try {
37572       result = Dali::KeyFrames::New();
37573     } catch (std::out_of_range& e) {
37574       {
37575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37576       };
37577     } catch (std::exception& e) {
37578       {
37579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37580       };
37581     } catch (...) {
37582       {
37583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37584       };
37585     }
37586   }
37587   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37588   return jresult;
37589 }
37590
37591
37592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37593   void * jresult ;
37594   Dali::BaseHandle arg1 ;
37595   Dali::BaseHandle *argp1 ;
37596   Dali::KeyFrames result;
37597
37598   argp1 = (Dali::BaseHandle *)jarg1;
37599   if (!argp1) {
37600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37601     return 0;
37602   }
37603   arg1 = *argp1;
37604   {
37605     try {
37606       result = Dali::KeyFrames::DownCast(arg1);
37607     } catch (std::out_of_range& e) {
37608       {
37609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37610       };
37611     } catch (std::exception& e) {
37612       {
37613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37614       };
37615     } catch (...) {
37616       {
37617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37618       };
37619     }
37620   }
37621   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37622   return jresult;
37623 }
37624
37625
37626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37627   void * jresult ;
37628   Dali::KeyFrames *result = 0 ;
37629
37630   {
37631     try {
37632       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37633     } catch (std::out_of_range& e) {
37634       {
37635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37636       };
37637     } catch (std::exception& e) {
37638       {
37639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37640       };
37641     } catch (...) {
37642       {
37643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37644       };
37645     }
37646   }
37647   jresult = (void *)result;
37648   return jresult;
37649 }
37650
37651
37652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37653   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37654
37655   arg1 = (Dali::KeyFrames *)jarg1;
37656   {
37657     try {
37658       delete arg1;
37659     } catch (std::out_of_range& e) {
37660       {
37661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37662       };
37663     } catch (std::exception& e) {
37664       {
37665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37666       };
37667     } catch (...) {
37668       {
37669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37670       };
37671     }
37672   }
37673 }
37674
37675
37676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37677   void * jresult ;
37678   Dali::KeyFrames *arg1 = 0 ;
37679   Dali::KeyFrames *result = 0 ;
37680
37681   arg1 = (Dali::KeyFrames *)jarg1;
37682   if (!arg1) {
37683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37684     return 0;
37685   }
37686   {
37687     try {
37688       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37689     } catch (std::out_of_range& e) {
37690       {
37691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37692       };
37693     } catch (std::exception& e) {
37694       {
37695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37696       };
37697     } catch (...) {
37698       {
37699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37700       };
37701     }
37702   }
37703   jresult = (void *)result;
37704   return jresult;
37705 }
37706
37707
37708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37709   void * jresult ;
37710   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37711   Dali::KeyFrames *arg2 = 0 ;
37712   Dali::KeyFrames *result = 0 ;
37713
37714   arg1 = (Dali::KeyFrames *)jarg1;
37715   arg2 = (Dali::KeyFrames *)jarg2;
37716   if (!arg2) {
37717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37718     return 0;
37719   }
37720   {
37721     try {
37722       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37723     } catch (std::out_of_range& e) {
37724       {
37725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37726       };
37727     } catch (std::exception& e) {
37728       {
37729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37730       };
37731     } catch (...) {
37732       {
37733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37734       };
37735     }
37736   }
37737   jresult = (void *)result;
37738   return jresult;
37739 }
37740
37741
37742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37743   int jresult ;
37744   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37745   Dali::Property::Type result;
37746
37747   arg1 = (Dali::KeyFrames *)jarg1;
37748   {
37749     try {
37750       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37751     } catch (std::out_of_range& e) {
37752       {
37753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37754       };
37755     } catch (std::exception& e) {
37756       {
37757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37758       };
37759     } catch (...) {
37760       {
37761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37762       };
37763     }
37764   }
37765   jresult = (int)result;
37766   return jresult;
37767 }
37768
37769
37770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37771   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37772   float arg2 ;
37773   Dali::Property::Value arg3 ;
37774   Dali::Property::Value *argp3 ;
37775
37776   arg1 = (Dali::KeyFrames *)jarg1;
37777   arg2 = (float)jarg2;
37778   argp3 = (Dali::Property::Value *)jarg3;
37779   if (!argp3) {
37780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37781     return ;
37782   }
37783   arg3 = *argp3;
37784   {
37785     try {
37786       (arg1)->Add(arg2,arg3);
37787     } catch (std::out_of_range& e) {
37788       {
37789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37790       };
37791     } catch (std::exception& e) {
37792       {
37793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37794       };
37795     } catch (...) {
37796       {
37797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37798       };
37799     }
37800   }
37801 }
37802
37803
37804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37805   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37806   float arg2 ;
37807   Dali::Property::Value arg3 ;
37808   Dali::AlphaFunction arg4 ;
37809   Dali::Property::Value *argp3 ;
37810   Dali::AlphaFunction *argp4 ;
37811
37812   arg1 = (Dali::KeyFrames *)jarg1;
37813   arg2 = (float)jarg2;
37814   argp3 = (Dali::Property::Value *)jarg3;
37815   if (!argp3) {
37816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37817     return ;
37818   }
37819   arg3 = *argp3;
37820   argp4 = (Dali::AlphaFunction *)jarg4;
37821   if (!argp4) {
37822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37823     return ;
37824   }
37825   arg4 = *argp4;
37826   {
37827     try {
37828       (arg1)->Add(arg2,arg3,arg4);
37829     } catch (std::out_of_range& e) {
37830       {
37831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37832       };
37833     } catch (std::exception& e) {
37834       {
37835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37836       };
37837     } catch (...) {
37838       {
37839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37840       };
37841     }
37842   }
37843 }
37844
37845
37846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37847   int jresult ;
37848   int result;
37849
37850   result = (int)Dali::Path::Property::POINTS;
37851   jresult = (int)result;
37852   return jresult;
37853 }
37854
37855
37856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37857   int jresult ;
37858   int result;
37859
37860   result = (int)Dali::Path::Property::CONTROL_POINTS;
37861   jresult = (int)result;
37862   return jresult;
37863 }
37864
37865
37866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37867   void * jresult ;
37868   Dali::Path::Property *result = 0 ;
37869
37870   {
37871     try {
37872       result = (Dali::Path::Property *)new Dali::Path::Property();
37873     } catch (std::out_of_range& e) {
37874       {
37875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37876       };
37877     } catch (std::exception& e) {
37878       {
37879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37880       };
37881     } catch (...) {
37882       {
37883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37884       };
37885     }
37886   }
37887   jresult = (void *)result;
37888   return jresult;
37889 }
37890
37891
37892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37893   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37894
37895   arg1 = (Dali::Path::Property *)jarg1;
37896   {
37897     try {
37898       delete arg1;
37899     } catch (std::out_of_range& e) {
37900       {
37901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37902       };
37903     } catch (std::exception& e) {
37904       {
37905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37906       };
37907     } catch (...) {
37908       {
37909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37910       };
37911     }
37912   }
37913 }
37914
37915
37916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
37917   void * jresult ;
37918   Dali::Path result;
37919
37920   {
37921     try {
37922       result = Dali::Path::New();
37923     } catch (std::out_of_range& e) {
37924       {
37925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37926       };
37927     } catch (std::exception& e) {
37928       {
37929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37930       };
37931     } catch (...) {
37932       {
37933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37934       };
37935     }
37936   }
37937   jresult = new Dali::Path((const Dali::Path &)result);
37938   return jresult;
37939 }
37940
37941
37942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
37943   void * jresult ;
37944   Dali::BaseHandle arg1 ;
37945   Dali::BaseHandle *argp1 ;
37946   Dali::Path result;
37947
37948   argp1 = (Dali::BaseHandle *)jarg1;
37949   if (!argp1) {
37950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37951     return 0;
37952   }
37953   arg1 = *argp1;
37954   {
37955     try {
37956       result = Dali::Path::DownCast(arg1);
37957     } catch (std::out_of_range& e) {
37958       {
37959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37960       };
37961     } catch (std::exception& e) {
37962       {
37963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37964       };
37965     } catch (...) {
37966       {
37967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37968       };
37969     }
37970   }
37971   jresult = new Dali::Path((const Dali::Path &)result);
37972   return jresult;
37973 }
37974
37975
37976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
37977   void * jresult ;
37978   Dali::Path *result = 0 ;
37979
37980   {
37981     try {
37982       result = (Dali::Path *)new Dali::Path();
37983     } catch (std::out_of_range& e) {
37984       {
37985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37986       };
37987     } catch (std::exception& e) {
37988       {
37989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37990       };
37991     } catch (...) {
37992       {
37993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37994       };
37995     }
37996   }
37997   jresult = (void *)result;
37998   return jresult;
37999 }
38000
38001
38002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
38003   Dali::Path *arg1 = (Dali::Path *) 0 ;
38004
38005   arg1 = (Dali::Path *)jarg1;
38006   {
38007     try {
38008       delete arg1;
38009     } catch (std::out_of_range& e) {
38010       {
38011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38012       };
38013     } catch (std::exception& e) {
38014       {
38015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38016       };
38017     } catch (...) {
38018       {
38019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38020       };
38021     }
38022   }
38023 }
38024
38025
38026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
38027   void * jresult ;
38028   Dali::Path *arg1 = 0 ;
38029   Dali::Path *result = 0 ;
38030
38031   arg1 = (Dali::Path *)jarg1;
38032   if (!arg1) {
38033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38034     return 0;
38035   }
38036   {
38037     try {
38038       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
38039     } catch (std::out_of_range& e) {
38040       {
38041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38042       };
38043     } catch (std::exception& e) {
38044       {
38045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38046       };
38047     } catch (...) {
38048       {
38049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38050       };
38051     }
38052   }
38053   jresult = (void *)result;
38054   return jresult;
38055 }
38056
38057
38058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
38059   void * jresult ;
38060   Dali::Path *arg1 = (Dali::Path *) 0 ;
38061   Dali::Path *arg2 = 0 ;
38062   Dali::Path *result = 0 ;
38063
38064   arg1 = (Dali::Path *)jarg1;
38065   arg2 = (Dali::Path *)jarg2;
38066   if (!arg2) {
38067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38068     return 0;
38069   }
38070   {
38071     try {
38072       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
38073     } catch (std::out_of_range& e) {
38074       {
38075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38076       };
38077     } catch (std::exception& e) {
38078       {
38079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38080       };
38081     } catch (...) {
38082       {
38083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38084       };
38085     }
38086   }
38087   jresult = (void *)result;
38088   return jresult;
38089 }
38090
38091
38092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38093   Dali::Path *arg1 = (Dali::Path *) 0 ;
38094   Dali::Vector3 *arg2 = 0 ;
38095
38096   arg1 = (Dali::Path *)jarg1;
38097   arg2 = (Dali::Vector3 *)jarg2;
38098   if (!arg2) {
38099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38100     return ;
38101   }
38102   {
38103     try {
38104       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38105     } catch (std::out_of_range& e) {
38106       {
38107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38108       };
38109     } catch (std::exception& e) {
38110       {
38111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38112       };
38113     } catch (...) {
38114       {
38115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38116       };
38117     }
38118   }
38119 }
38120
38121
38122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38123   Dali::Path *arg1 = (Dali::Path *) 0 ;
38124   Dali::Vector3 *arg2 = 0 ;
38125
38126   arg1 = (Dali::Path *)jarg1;
38127   arg2 = (Dali::Vector3 *)jarg2;
38128   if (!arg2) {
38129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38130     return ;
38131   }
38132   {
38133     try {
38134       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38135     } catch (std::out_of_range& e) {
38136       {
38137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38138       };
38139     } catch (std::exception& e) {
38140       {
38141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38142       };
38143     } catch (...) {
38144       {
38145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38146       };
38147     }
38148   }
38149 }
38150
38151
38152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38153   Dali::Path *arg1 = (Dali::Path *) 0 ;
38154   float arg2 ;
38155
38156   arg1 = (Dali::Path *)jarg1;
38157   arg2 = (float)jarg2;
38158   {
38159     try {
38160       (arg1)->GenerateControlPoints(arg2);
38161     } catch (std::out_of_range& e) {
38162       {
38163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38164       };
38165     } catch (std::exception& e) {
38166       {
38167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38168       };
38169     } catch (...) {
38170       {
38171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38172       };
38173     }
38174   }
38175 }
38176
38177
38178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38179   Dali::Path *arg1 = (Dali::Path *) 0 ;
38180   float arg2 ;
38181   Dali::Vector3 *arg3 = 0 ;
38182   Dali::Vector3 *arg4 = 0 ;
38183
38184   arg1 = (Dali::Path *)jarg1;
38185   arg2 = (float)jarg2;
38186   arg3 = (Dali::Vector3 *)jarg3;
38187   if (!arg3) {
38188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38189     return ;
38190   }
38191   arg4 = (Dali::Vector3 *)jarg4;
38192   if (!arg4) {
38193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38194     return ;
38195   }
38196   {
38197     try {
38198       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38199     } catch (std::out_of_range& e) {
38200       {
38201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38202       };
38203     } catch (std::exception& e) {
38204       {
38205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38206       };
38207     } catch (...) {
38208       {
38209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38210       };
38211     }
38212   }
38213 }
38214
38215
38216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38217   void * jresult ;
38218   Dali::Path *arg1 = (Dali::Path *) 0 ;
38219   size_t arg2 ;
38220   Dali::Vector3 *result = 0 ;
38221
38222   arg1 = (Dali::Path *)jarg1;
38223   arg2 = (size_t)jarg2;
38224   {
38225     try {
38226       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38227     } catch (std::out_of_range& e) {
38228       {
38229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38230       };
38231     } catch (std::exception& e) {
38232       {
38233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38234       };
38235     } catch (...) {
38236       {
38237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38238       };
38239     }
38240   }
38241   jresult = (void *)result;
38242   return jresult;
38243 }
38244
38245
38246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38247   void * jresult ;
38248   Dali::Path *arg1 = (Dali::Path *) 0 ;
38249   size_t arg2 ;
38250   Dali::Vector3 *result = 0 ;
38251
38252   arg1 = (Dali::Path *)jarg1;
38253   arg2 = (size_t)jarg2;
38254   {
38255     try {
38256       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38257     } catch (std::out_of_range& e) {
38258       {
38259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38260       };
38261     } catch (std::exception& e) {
38262       {
38263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38264       };
38265     } catch (...) {
38266       {
38267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38268       };
38269     }
38270   }
38271   jresult = (void *)result;
38272   return jresult;
38273 }
38274
38275
38276 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38277   unsigned long jresult ;
38278   Dali::Path *arg1 = (Dali::Path *) 0 ;
38279   size_t result;
38280
38281   arg1 = (Dali::Path *)jarg1;
38282   {
38283     try {
38284       result = ((Dali::Path const *)arg1)->GetPointCount();
38285     } catch (std::out_of_range& e) {
38286       {
38287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38288       };
38289     } catch (std::exception& e) {
38290       {
38291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38292       };
38293     } catch (...) {
38294       {
38295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38296       };
38297     }
38298   }
38299   jresult = (unsigned long)result;
38300   return jresult;
38301 }
38302
38303
38304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38305   void * jresult ;
38306   float arg1 ;
38307   Dali::TimePeriod *result = 0 ;
38308
38309   arg1 = (float)jarg1;
38310   {
38311     try {
38312       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38313     } catch (std::out_of_range& e) {
38314       {
38315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38316       };
38317     } catch (std::exception& e) {
38318       {
38319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38320       };
38321     } catch (...) {
38322       {
38323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38324       };
38325     }
38326   }
38327   jresult = (void *)result;
38328   return jresult;
38329 }
38330
38331
38332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38333   void * jresult ;
38334   float arg1 ;
38335   float arg2 ;
38336   Dali::TimePeriod *result = 0 ;
38337
38338   arg1 = (float)jarg1;
38339   arg2 = (float)jarg2;
38340   {
38341     try {
38342       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38343     } catch (std::out_of_range& e) {
38344       {
38345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38346       };
38347     } catch (std::exception& e) {
38348       {
38349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38350       };
38351     } catch (...) {
38352       {
38353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38354       };
38355     }
38356   }
38357   jresult = (void *)result;
38358   return jresult;
38359 }
38360
38361
38362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38363   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38364
38365   arg1 = (Dali::TimePeriod *)jarg1;
38366   {
38367     try {
38368       delete arg1;
38369     } catch (std::out_of_range& e) {
38370       {
38371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38372       };
38373     } catch (std::exception& e) {
38374       {
38375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38376       };
38377     } catch (...) {
38378       {
38379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38380       };
38381     }
38382   }
38383 }
38384
38385
38386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38387   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38388   float arg2 ;
38389
38390   arg1 = (Dali::TimePeriod *)jarg1;
38391   arg2 = (float)jarg2;
38392   if (arg1) (arg1)->delaySeconds = arg2;
38393 }
38394
38395
38396 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38397   float jresult ;
38398   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38399   float result;
38400
38401   arg1 = (Dali::TimePeriod *)jarg1;
38402   result = (float) ((arg1)->delaySeconds);
38403   jresult = result;
38404   return jresult;
38405 }
38406
38407
38408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38409   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38410   float arg2 ;
38411
38412   arg1 = (Dali::TimePeriod *)jarg1;
38413   arg2 = (float)jarg2;
38414   if (arg1) (arg1)->durationSeconds = arg2;
38415 }
38416
38417
38418 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38419   float jresult ;
38420   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38421   float result;
38422
38423   arg1 = (Dali::TimePeriod *)jarg1;
38424   result = (float) ((arg1)->durationSeconds);
38425   jresult = result;
38426   return jresult;
38427 }
38428
38429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
38430   int jresult ;
38431   int result;
38432
38433   result = (int)Dali::LinearConstrainer::Property::VALUE;
38434   jresult = (int)result;
38435   return jresult;
38436 }
38437
38438
38439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
38440   int jresult ;
38441   int result;
38442
38443   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
38444   jresult = (int)result;
38445   return jresult;
38446 }
38447
38448
38449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
38450   void * jresult ;
38451   Dali::LinearConstrainer::Property *result = 0 ;
38452
38453   {
38454     try {
38455       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
38456     } catch (std::out_of_range& e) {
38457       {
38458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38459       };
38460     } catch (std::exception& e) {
38461       {
38462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38463       };
38464     } catch (...) {
38465       {
38466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38467       };
38468     }
38469   }
38470   jresult = (void *)result;
38471   return jresult;
38472 }
38473
38474
38475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
38476   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
38477
38478   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
38479   {
38480     try {
38481       delete arg1;
38482     } catch (std::out_of_range& e) {
38483       {
38484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38485       };
38486     } catch (std::exception& e) {
38487       {
38488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38489       };
38490     } catch (...) {
38491       {
38492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38493       };
38494     }
38495   }
38496 }
38497
38498
38499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
38500   void * jresult ;
38501   Dali::LinearConstrainer result;
38502
38503   {
38504     try {
38505       result = Dali::LinearConstrainer::New();
38506     } catch (std::out_of_range& e) {
38507       {
38508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38509       };
38510     } catch (std::exception& e) {
38511       {
38512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38513       };
38514     } catch (...) {
38515       {
38516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38517       };
38518     }
38519   }
38520   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
38521   return jresult;
38522 }
38523
38524
38525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
38526   void * jresult ;
38527   Dali::BaseHandle arg1 ;
38528   Dali::BaseHandle *argp1 ;
38529   Dali::LinearConstrainer result;
38530
38531   argp1 = (Dali::BaseHandle *)jarg1;
38532   if (!argp1) {
38533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38534     return 0;
38535   }
38536   arg1 = *argp1;
38537   {
38538     try {
38539       result = Dali::LinearConstrainer::DownCast(arg1);
38540     } catch (std::out_of_range& e) {
38541       {
38542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38543       };
38544     } catch (std::exception& e) {
38545       {
38546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38547       };
38548     } catch (...) {
38549       {
38550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38551       };
38552     }
38553   }
38554   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
38555   return jresult;
38556 }
38557
38558
38559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
38560   void * jresult ;
38561   Dali::LinearConstrainer *result = 0 ;
38562
38563   {
38564     try {
38565       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
38566     } catch (std::out_of_range& e) {
38567       {
38568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38569       };
38570     } catch (std::exception& e) {
38571       {
38572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38573       };
38574     } catch (...) {
38575       {
38576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38577       };
38578     }
38579   }
38580   jresult = (void *)result;
38581   return jresult;
38582 }
38583
38584
38585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
38586   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38587
38588   arg1 = (Dali::LinearConstrainer *)jarg1;
38589   {
38590     try {
38591       delete arg1;
38592     } catch (std::out_of_range& e) {
38593       {
38594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38595       };
38596     } catch (std::exception& e) {
38597       {
38598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38599       };
38600     } catch (...) {
38601       {
38602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38603       };
38604     }
38605   }
38606 }
38607
38608
38609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
38610   void * jresult ;
38611   Dali::LinearConstrainer *arg1 = 0 ;
38612   Dali::LinearConstrainer *result = 0 ;
38613
38614   arg1 = (Dali::LinearConstrainer *)jarg1;
38615   if (!arg1) {
38616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
38617     return 0;
38618   }
38619   {
38620     try {
38621       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
38622     } catch (std::out_of_range& e) {
38623       {
38624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38625       };
38626     } catch (std::exception& e) {
38627       {
38628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38629       };
38630     } catch (...) {
38631       {
38632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38633       };
38634     }
38635   }
38636   jresult = (void *)result;
38637   return jresult;
38638 }
38639
38640
38641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
38642   void * jresult ;
38643   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38644   Dali::LinearConstrainer *arg2 = 0 ;
38645   Dali::LinearConstrainer *result = 0 ;
38646
38647   arg1 = (Dali::LinearConstrainer *)jarg1;
38648   arg2 = (Dali::LinearConstrainer *)jarg2;
38649   if (!arg2) {
38650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
38651     return 0;
38652   }
38653   {
38654     try {
38655       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
38656     } catch (std::out_of_range& e) {
38657       {
38658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38659       };
38660     } catch (std::exception& e) {
38661       {
38662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38663       };
38664     } catch (...) {
38665       {
38666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38667       };
38668     }
38669   }
38670   jresult = (void *)result;
38671   return jresult;
38672 }
38673
38674
38675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
38676   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38677   SwigValueWrapper< Dali::Property > arg2 ;
38678   SwigValueWrapper< Dali::Property > arg3 ;
38679   Dali::Vector2 *arg4 = 0 ;
38680   Dali::Vector2 *arg5 = 0 ;
38681   Dali::Property *argp2 ;
38682   Dali::Property *argp3 ;
38683
38684   arg1 = (Dali::LinearConstrainer *)jarg1;
38685   argp2 = (Dali::Property *)jarg2;
38686   if (!argp2) {
38687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38688     return ;
38689   }
38690   arg2 = *argp2;
38691   argp3 = (Dali::Property *)jarg3;
38692   if (!argp3) {
38693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38694     return ;
38695   }
38696   arg3 = *argp3;
38697   arg4 = (Dali::Vector2 *)jarg4;
38698   if (!arg4) {
38699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38700     return ;
38701   }
38702   arg5 = (Dali::Vector2 *)jarg5;
38703   if (!arg5) {
38704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38705     return ;
38706   }
38707   {
38708     try {
38709       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
38710     } catch (std::out_of_range& e) {
38711       {
38712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38713       };
38714     } catch (std::exception& e) {
38715       {
38716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38717       };
38718     } catch (...) {
38719       {
38720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38721       };
38722     }
38723   }
38724 }
38725
38726
38727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
38728   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38729   SwigValueWrapper< Dali::Property > arg2 ;
38730   SwigValueWrapper< Dali::Property > arg3 ;
38731   Dali::Vector2 *arg4 = 0 ;
38732   Dali::Property *argp2 ;
38733   Dali::Property *argp3 ;
38734
38735   arg1 = (Dali::LinearConstrainer *)jarg1;
38736   argp2 = (Dali::Property *)jarg2;
38737   if (!argp2) {
38738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38739     return ;
38740   }
38741   arg2 = *argp2;
38742   argp3 = (Dali::Property *)jarg3;
38743   if (!argp3) {
38744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38745     return ;
38746   }
38747   arg3 = *argp3;
38748   arg4 = (Dali::Vector2 *)jarg4;
38749   if (!arg4) {
38750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38751     return ;
38752   }
38753   {
38754     try {
38755       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
38756     } catch (std::out_of_range& e) {
38757       {
38758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38759       };
38760     } catch (std::exception& e) {
38761       {
38762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38763       };
38764     } catch (...) {
38765       {
38766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38767       };
38768     }
38769   }
38770 }
38771
38772
38773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
38774   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38775   Dali::Handle *arg2 = 0 ;
38776
38777   arg1 = (Dali::LinearConstrainer *)jarg1;
38778   arg2 = (Dali::Handle *)jarg2;
38779   if (!arg2) {
38780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
38781     return ;
38782   }
38783   {
38784     try {
38785       (arg1)->Remove(*arg2);
38786     } catch (std::out_of_range& e) {
38787       {
38788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38789       };
38790     } catch (std::exception& e) {
38791       {
38792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38793       };
38794     } catch (...) {
38795       {
38796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38797       };
38798     }
38799   }
38800 }
38801
38802
38803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
38804   int jresult ;
38805   int result;
38806
38807   result = (int)Dali::PathConstrainer::Property::FORWARD;
38808   jresult = (int)result;
38809   return jresult;
38810 }
38811
38812
38813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
38814   int jresult ;
38815   int result;
38816
38817   result = (int)Dali::PathConstrainer::Property::POINTS;
38818   jresult = (int)result;
38819   return jresult;
38820 }
38821
38822
38823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
38824   int jresult ;
38825   int result;
38826
38827   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
38828   jresult = (int)result;
38829   return jresult;
38830 }
38831
38832
38833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
38834   void * jresult ;
38835   Dali::PathConstrainer::Property *result = 0 ;
38836
38837   {
38838     try {
38839       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
38840     } catch (std::out_of_range& e) {
38841       {
38842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38843       };
38844     } catch (std::exception& e) {
38845       {
38846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38847       };
38848     } catch (...) {
38849       {
38850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38851       };
38852     }
38853   }
38854   jresult = (void *)result;
38855   return jresult;
38856 }
38857
38858
38859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
38860   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
38861
38862   arg1 = (Dali::PathConstrainer::Property *)jarg1;
38863   {
38864     try {
38865       delete arg1;
38866     } catch (std::out_of_range& e) {
38867       {
38868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38869       };
38870     } catch (std::exception& e) {
38871       {
38872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38873       };
38874     } catch (...) {
38875       {
38876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38877       };
38878     }
38879   }
38880 }
38881
38882
38883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
38884   void * jresult ;
38885   Dali::PathConstrainer result;
38886
38887   {
38888     try {
38889       result = Dali::PathConstrainer::New();
38890     } catch (std::out_of_range& e) {
38891       {
38892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38893       };
38894     } catch (std::exception& e) {
38895       {
38896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38897       };
38898     } catch (...) {
38899       {
38900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38901       };
38902     }
38903   }
38904   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
38905   return jresult;
38906 }
38907
38908
38909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
38910   void * jresult ;
38911   Dali::BaseHandle arg1 ;
38912   Dali::BaseHandle *argp1 ;
38913   Dali::PathConstrainer result;
38914
38915   argp1 = (Dali::BaseHandle *)jarg1;
38916   if (!argp1) {
38917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38918     return 0;
38919   }
38920   arg1 = *argp1;
38921   {
38922     try {
38923       result = Dali::PathConstrainer::DownCast(arg1);
38924     } catch (std::out_of_range& e) {
38925       {
38926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38927       };
38928     } catch (std::exception& e) {
38929       {
38930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38931       };
38932     } catch (...) {
38933       {
38934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38935       };
38936     }
38937   }
38938   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
38939   return jresult;
38940 }
38941
38942
38943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
38944   void * jresult ;
38945   Dali::PathConstrainer *result = 0 ;
38946
38947   {
38948     try {
38949       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
38950     } catch (std::out_of_range& e) {
38951       {
38952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38953       };
38954     } catch (std::exception& e) {
38955       {
38956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38957       };
38958     } catch (...) {
38959       {
38960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38961       };
38962     }
38963   }
38964   jresult = (void *)result;
38965   return jresult;
38966 }
38967
38968
38969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
38970   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
38971
38972   arg1 = (Dali::PathConstrainer *)jarg1;
38973   {
38974     try {
38975       delete arg1;
38976     } catch (std::out_of_range& e) {
38977       {
38978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38979       };
38980     } catch (std::exception& e) {
38981       {
38982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38983       };
38984     } catch (...) {
38985       {
38986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38987       };
38988     }
38989   }
38990 }
38991
38992
38993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
38994   void * jresult ;
38995   Dali::PathConstrainer *arg1 = 0 ;
38996   Dali::PathConstrainer *result = 0 ;
38997
38998   arg1 = (Dali::PathConstrainer *)jarg1;
38999   if (!arg1) {
39000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
39001     return 0;
39002   }
39003   {
39004     try {
39005       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
39006     } catch (std::out_of_range& e) {
39007       {
39008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39009       };
39010     } catch (std::exception& e) {
39011       {
39012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39013       };
39014     } catch (...) {
39015       {
39016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39017       };
39018     }
39019   }
39020   jresult = (void *)result;
39021   return jresult;
39022 }
39023
39024
39025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
39026   void * jresult ;
39027   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39028   Dali::PathConstrainer *arg2 = 0 ;
39029   Dali::PathConstrainer *result = 0 ;
39030
39031   arg1 = (Dali::PathConstrainer *)jarg1;
39032   arg2 = (Dali::PathConstrainer *)jarg2;
39033   if (!arg2) {
39034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
39035     return 0;
39036   }
39037   {
39038     try {
39039       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
39040     } catch (std::out_of_range& e) {
39041       {
39042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39043       };
39044     } catch (std::exception& e) {
39045       {
39046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39047       };
39048     } catch (...) {
39049       {
39050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39051       };
39052     }
39053   }
39054   jresult = (void *)result;
39055   return jresult;
39056 }
39057
39058
39059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39060   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39061   SwigValueWrapper< Dali::Property > arg2 ;
39062   SwigValueWrapper< Dali::Property > arg3 ;
39063   Dali::Vector2 *arg4 = 0 ;
39064   Dali::Vector2 *arg5 = 0 ;
39065   Dali::Property *argp2 ;
39066   Dali::Property *argp3 ;
39067
39068   arg1 = (Dali::PathConstrainer *)jarg1;
39069   argp2 = (Dali::Property *)jarg2;
39070   if (!argp2) {
39071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39072     return ;
39073   }
39074   arg2 = *argp2;
39075   argp3 = (Dali::Property *)jarg3;
39076   if (!argp3) {
39077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39078     return ;
39079   }
39080   arg3 = *argp3;
39081   arg4 = (Dali::Vector2 *)jarg4;
39082   if (!arg4) {
39083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39084     return ;
39085   }
39086   arg5 = (Dali::Vector2 *)jarg5;
39087   if (!arg5) {
39088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39089     return ;
39090   }
39091   {
39092     try {
39093       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
39094     } catch (std::out_of_range& e) {
39095       {
39096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39097       };
39098     } catch (std::exception& e) {
39099       {
39100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39101       };
39102     } catch (...) {
39103       {
39104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39105       };
39106     }
39107   }
39108 }
39109
39110
39111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39112   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39113   SwigValueWrapper< Dali::Property > arg2 ;
39114   SwigValueWrapper< Dali::Property > arg3 ;
39115   Dali::Vector2 *arg4 = 0 ;
39116   Dali::Property *argp2 ;
39117   Dali::Property *argp3 ;
39118
39119   arg1 = (Dali::PathConstrainer *)jarg1;
39120   argp2 = (Dali::Property *)jarg2;
39121   if (!argp2) {
39122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39123     return ;
39124   }
39125   arg2 = *argp2;
39126   argp3 = (Dali::Property *)jarg3;
39127   if (!argp3) {
39128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39129     return ;
39130   }
39131   arg3 = *argp3;
39132   arg4 = (Dali::Vector2 *)jarg4;
39133   if (!arg4) {
39134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39135     return ;
39136   }
39137   {
39138     try {
39139       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
39140     } catch (std::out_of_range& e) {
39141       {
39142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39143       };
39144     } catch (std::exception& e) {
39145       {
39146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39147       };
39148     } catch (...) {
39149       {
39150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39151       };
39152     }
39153   }
39154 }
39155
39156
39157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
39158   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39159   Dali::Handle *arg2 = 0 ;
39160
39161   arg1 = (Dali::PathConstrainer *)jarg1;
39162   arg2 = (Dali::Handle *)jarg2;
39163   if (!arg2) {
39164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
39165     return ;
39166   }
39167   {
39168     try {
39169       (arg1)->Remove(*arg2);
39170     } catch (std::out_of_range& e) {
39171       {
39172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39173       };
39174     } catch (std::exception& e) {
39175       {
39176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39177       };
39178     } catch (...) {
39179       {
39180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39181       };
39182     }
39183   }
39184 }
39185
39186
39187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
39188   int jresult ;
39189   Dali::FittingMode::Type result;
39190
39191   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
39192   jresult = (int)result;
39193   return jresult;
39194 }
39195
39196
39197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
39198   int jresult ;
39199   Dali::SamplingMode::Type result;
39200
39201   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
39202   jresult = (int)result;
39203   return jresult;
39204 }
39205
39206
39207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
39208   void * jresult ;
39209   Dali::BufferImage *result = 0 ;
39210
39211   {
39212     try {
39213       result = (Dali::BufferImage *)new Dali::BufferImage();
39214     } catch (std::out_of_range& e) {
39215       {
39216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39217       };
39218     } catch (std::exception& e) {
39219       {
39220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39221       };
39222     } catch (...) {
39223       {
39224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39225       };
39226     }
39227   }
39228   jresult = (void *)result;
39229   return jresult;
39230 }
39231
39232
39233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
39234   void * jresult ;
39235   unsigned int arg1 ;
39236   unsigned int arg2 ;
39237   Dali::Pixel::Format arg3 ;
39238   Dali::BufferImage result;
39239
39240   arg1 = (unsigned int)jarg1;
39241   arg2 = (unsigned int)jarg2;
39242   arg3 = (Dali::Pixel::Format)jarg3;
39243   {
39244     try {
39245       result = Dali::BufferImage::New(arg1,arg2,arg3);
39246     } catch (std::out_of_range& e) {
39247       {
39248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39249       };
39250     } catch (std::exception& e) {
39251       {
39252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39253       };
39254     } catch (...) {
39255       {
39256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39257       };
39258     }
39259   }
39260   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39261   return jresult;
39262 }
39263
39264
39265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
39266   void * jresult ;
39267   unsigned int arg1 ;
39268   unsigned int arg2 ;
39269   Dali::BufferImage result;
39270
39271   arg1 = (unsigned int)jarg1;
39272   arg2 = (unsigned int)jarg2;
39273   {
39274     try {
39275       result = Dali::BufferImage::New(arg1,arg2);
39276     } catch (std::out_of_range& e) {
39277       {
39278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39279       };
39280     } catch (std::exception& e) {
39281       {
39282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39283       };
39284     } catch (...) {
39285       {
39286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39287       };
39288     }
39289   }
39290   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39291   return jresult;
39292 }
39293
39294
39295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
39296   void * jresult ;
39297   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39298   unsigned int arg2 ;
39299   unsigned int arg3 ;
39300   Dali::Pixel::Format arg4 ;
39301   unsigned int arg5 ;
39302   Dali::BufferImage result;
39303
39304   arg1 = jarg1;
39305   arg2 = (unsigned int)jarg2;
39306   arg3 = (unsigned int)jarg3;
39307   arg4 = (Dali::Pixel::Format)jarg4;
39308   arg5 = (unsigned int)jarg5;
39309   {
39310     try {
39311       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
39312     } catch (std::out_of_range& e) {
39313       {
39314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39315       };
39316     } catch (std::exception& e) {
39317       {
39318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39319       };
39320     } catch (...) {
39321       {
39322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39323       };
39324     }
39325   }
39326   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39327
39328
39329   return jresult;
39330 }
39331
39332
39333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
39334   void * jresult ;
39335   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39336   unsigned int arg2 ;
39337   unsigned int arg3 ;
39338   Dali::Pixel::Format arg4 ;
39339   Dali::BufferImage result;
39340
39341   arg1 = jarg1;
39342   arg2 = (unsigned int)jarg2;
39343   arg3 = (unsigned int)jarg3;
39344   arg4 = (Dali::Pixel::Format)jarg4;
39345   {
39346     try {
39347       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
39348     } catch (std::out_of_range& e) {
39349       {
39350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39351       };
39352     } catch (std::exception& e) {
39353       {
39354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39355       };
39356     } catch (...) {
39357       {
39358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39359       };
39360     }
39361   }
39362   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39363
39364
39365   return jresult;
39366 }
39367
39368
39369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
39370   void * jresult ;
39371   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39372   unsigned int arg2 ;
39373   unsigned int arg3 ;
39374   Dali::BufferImage result;
39375
39376   arg1 = jarg1;
39377   arg2 = (unsigned int)jarg2;
39378   arg3 = (unsigned int)jarg3;
39379   {
39380     try {
39381       result = Dali::BufferImage::New(arg1,arg2,arg3);
39382     } catch (std::out_of_range& e) {
39383       {
39384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39385       };
39386     } catch (std::exception& e) {
39387       {
39388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39389       };
39390     } catch (...) {
39391       {
39392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39393       };
39394     }
39395   }
39396   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39397
39398
39399   return jresult;
39400 }
39401
39402
39403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
39404   void * jresult ;
39405   Dali::BaseHandle arg1 ;
39406   Dali::BaseHandle *argp1 ;
39407   Dali::BufferImage result;
39408
39409   argp1 = (Dali::BaseHandle *)jarg1;
39410   if (!argp1) {
39411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39412     return 0;
39413   }
39414   arg1 = *argp1;
39415   {
39416     try {
39417       result = Dali::BufferImage::DownCast(arg1);
39418     } catch (std::out_of_range& e) {
39419       {
39420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39421       };
39422     } catch (std::exception& e) {
39423       {
39424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39425       };
39426     } catch (...) {
39427       {
39428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39429       };
39430     }
39431   }
39432   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39433   return jresult;
39434 }
39435
39436
39437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
39438   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39439
39440   arg1 = (Dali::BufferImage *)jarg1;
39441   {
39442     try {
39443       delete arg1;
39444     } catch (std::out_of_range& e) {
39445       {
39446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39447       };
39448     } catch (std::exception& e) {
39449       {
39450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39451       };
39452     } catch (...) {
39453       {
39454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39455       };
39456     }
39457   }
39458 }
39459
39460
39461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
39462   void * jresult ;
39463   Dali::BufferImage *arg1 = 0 ;
39464   Dali::BufferImage *result = 0 ;
39465
39466   arg1 = (Dali::BufferImage *)jarg1;
39467   if (!arg1) {
39468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
39469     return 0;
39470   }
39471   {
39472     try {
39473       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
39474     } catch (std::out_of_range& e) {
39475       {
39476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39477       };
39478     } catch (std::exception& e) {
39479       {
39480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39481       };
39482     } catch (...) {
39483       {
39484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39485       };
39486     }
39487   }
39488   jresult = (void *)result;
39489   return jresult;
39490 }
39491
39492
39493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
39494   void * jresult ;
39495   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39496   Dali::BufferImage *arg2 = 0 ;
39497   Dali::BufferImage *result = 0 ;
39498
39499   arg1 = (Dali::BufferImage *)jarg1;
39500   arg2 = (Dali::BufferImage *)jarg2;
39501   if (!arg2) {
39502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
39503     return 0;
39504   }
39505   {
39506     try {
39507       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
39508     } catch (std::out_of_range& e) {
39509       {
39510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39511       };
39512     } catch (std::exception& e) {
39513       {
39514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39515       };
39516     } catch (...) {
39517       {
39518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39519       };
39520     }
39521   }
39522   jresult = (void *)result;
39523   return jresult;
39524 }
39525
39526
39527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
39528   void * jresult ;
39529   Dali::BufferImage result;
39530
39531   {
39532     try {
39533       result = Dali::BufferImage::WHITE();
39534     } catch (std::out_of_range& e) {
39535       {
39536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39537       };
39538     } catch (std::exception& e) {
39539       {
39540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39541       };
39542     } catch (...) {
39543       {
39544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39545       };
39546     }
39547   }
39548   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39549   return jresult;
39550 }
39551
39552
39553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
39554   void * jresult ;
39555   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39556   Dali::PixelBuffer *result = 0 ;
39557
39558   arg1 = (Dali::BufferImage *)jarg1;
39559   {
39560     try {
39561       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
39562     } catch (std::out_of_range& e) {
39563       {
39564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39565       };
39566     } catch (std::exception& e) {
39567       {
39568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39569       };
39570     } catch (...) {
39571       {
39572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39573       };
39574     }
39575   }
39576   jresult = (void *)result;
39577   return jresult;
39578 }
39579
39580
39581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
39582   unsigned int jresult ;
39583   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39584   unsigned int result;
39585
39586   arg1 = (Dali::BufferImage *)jarg1;
39587   {
39588     try {
39589       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
39590     } catch (std::out_of_range& e) {
39591       {
39592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39593       };
39594     } catch (std::exception& e) {
39595       {
39596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39597       };
39598     } catch (...) {
39599       {
39600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39601       };
39602     }
39603   }
39604   jresult = result;
39605   return jresult;
39606 }
39607
39608
39609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
39610   unsigned int jresult ;
39611   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39612   unsigned int result;
39613
39614   arg1 = (Dali::BufferImage *)jarg1;
39615   {
39616     try {
39617       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
39618     } catch (std::out_of_range& e) {
39619       {
39620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39621       };
39622     } catch (std::exception& e) {
39623       {
39624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39625       };
39626     } catch (...) {
39627       {
39628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39629       };
39630     }
39631   }
39632   jresult = result;
39633   return jresult;
39634 }
39635
39636
39637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
39638   int jresult ;
39639   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39640   Dali::Pixel::Format result;
39641
39642   arg1 = (Dali::BufferImage *)jarg1;
39643   {
39644     try {
39645       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
39646     } catch (std::out_of_range& e) {
39647       {
39648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39649       };
39650     } catch (std::exception& e) {
39651       {
39652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39653       };
39654     } catch (...) {
39655       {
39656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39657       };
39658     }
39659   }
39660   jresult = (int)result;
39661   return jresult;
39662 }
39663
39664
39665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
39666   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39667
39668   arg1 = (Dali::BufferImage *)jarg1;
39669   {
39670     try {
39671       (arg1)->Update();
39672     } catch (std::out_of_range& e) {
39673       {
39674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39675       };
39676     } catch (std::exception& e) {
39677       {
39678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39679       };
39680     } catch (...) {
39681       {
39682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39683       };
39684     }
39685   }
39686 }
39687
39688
39689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
39690   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39691   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
39692   Dali::RectArea *argp2 ;
39693
39694   arg1 = (Dali::BufferImage *)jarg1;
39695   argp2 = (Dali::RectArea *)jarg2;
39696   if (!argp2) {
39697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
39698     return ;
39699   }
39700   arg2 = *argp2;
39701   {
39702     try {
39703       (arg1)->Update(arg2);
39704     } catch (std::out_of_range& e) {
39705       {
39706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39707       };
39708     } catch (std::exception& e) {
39709       {
39710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39711       };
39712     } catch (...) {
39713       {
39714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39715       };
39716     }
39717   }
39718 }
39719
39720
39721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
39722   unsigned int jresult ;
39723   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39724   bool result;
39725
39726   arg1 = (Dali::BufferImage *)jarg1;
39727   {
39728     try {
39729       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
39730     } catch (std::out_of_range& e) {
39731       {
39732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39733       };
39734     } catch (std::exception& e) {
39735       {
39736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39737       };
39738     } catch (...) {
39739       {
39740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39741       };
39742     }
39743   }
39744   jresult = result;
39745   return jresult;
39746 }
39747
39748
39749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
39750   void * jresult ;
39751   Dali::EncodedBufferImage *result = 0 ;
39752
39753   {
39754     try {
39755       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
39756     } catch (std::out_of_range& e) {
39757       {
39758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39759       };
39760     } catch (std::exception& e) {
39761       {
39762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39763       };
39764     } catch (...) {
39765       {
39766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39767       };
39768     }
39769   }
39770   jresult = (void *)result;
39771   return jresult;
39772 }
39773
39774
39775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
39776   void * jresult ;
39777   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39778   std::size_t arg2 ;
39779   Dali::EncodedBufferImage result;
39780
39781   arg1 = (uint8_t *)jarg1;
39782   arg2 = (std::size_t)jarg2;
39783   {
39784     try {
39785       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
39786     } catch (std::out_of_range& e) {
39787       {
39788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39789       };
39790     } catch (std::exception& e) {
39791       {
39792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39793       };
39794     } catch (...) {
39795       {
39796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39797       };
39798     }
39799   }
39800   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39801   return jresult;
39802 }
39803
39804
39805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
39806   void * jresult ;
39807   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39808   std::size_t arg2 ;
39809   Dali::ImageDimensions arg3 ;
39810   Dali::FittingMode::Type arg4 ;
39811   Dali::SamplingMode::Type arg5 ;
39812   bool arg6 ;
39813   Dali::ImageDimensions *argp3 ;
39814   Dali::EncodedBufferImage result;
39815
39816   arg1 = (uint8_t *)jarg1;
39817   arg2 = (std::size_t)jarg2;
39818   argp3 = (Dali::ImageDimensions *)jarg3;
39819   if (!argp3) {
39820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39821     return 0;
39822   }
39823   arg3 = *argp3;
39824   arg4 = (Dali::FittingMode::Type)jarg4;
39825   arg5 = (Dali::SamplingMode::Type)jarg5;
39826   arg6 = jarg6 ? true : false;
39827   {
39828     try {
39829       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
39830     } catch (std::out_of_range& e) {
39831       {
39832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39833       };
39834     } catch (std::exception& e) {
39835       {
39836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39837       };
39838     } catch (...) {
39839       {
39840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39841       };
39842     }
39843   }
39844   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39845   return jresult;
39846 }
39847
39848
39849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
39850   void * jresult ;
39851   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39852   std::size_t arg2 ;
39853   Dali::ImageDimensions arg3 ;
39854   Dali::FittingMode::Type arg4 ;
39855   Dali::SamplingMode::Type arg5 ;
39856   Dali::ImageDimensions *argp3 ;
39857   Dali::EncodedBufferImage result;
39858
39859   arg1 = (uint8_t *)jarg1;
39860   arg2 = (std::size_t)jarg2;
39861   argp3 = (Dali::ImageDimensions *)jarg3;
39862   if (!argp3) {
39863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39864     return 0;
39865   }
39866   arg3 = *argp3;
39867   arg4 = (Dali::FittingMode::Type)jarg4;
39868   arg5 = (Dali::SamplingMode::Type)jarg5;
39869   {
39870     try {
39871       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
39872     } catch (std::out_of_range& e) {
39873       {
39874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39875       };
39876     } catch (std::exception& e) {
39877       {
39878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39879       };
39880     } catch (...) {
39881       {
39882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39883       };
39884     }
39885   }
39886   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39887   return jresult;
39888 }
39889
39890
39891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
39892   void * jresult ;
39893   Dali::BaseHandle arg1 ;
39894   Dali::BaseHandle *argp1 ;
39895   Dali::EncodedBufferImage result;
39896
39897   argp1 = (Dali::BaseHandle *)jarg1;
39898   if (!argp1) {
39899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39900     return 0;
39901   }
39902   arg1 = *argp1;
39903   {
39904     try {
39905       result = Dali::EncodedBufferImage::DownCast(arg1);
39906     } catch (std::out_of_range& e) {
39907       {
39908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39909       };
39910     } catch (std::exception& e) {
39911       {
39912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39913       };
39914     } catch (...) {
39915       {
39916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39917       };
39918     }
39919   }
39920   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39921   return jresult;
39922 }
39923
39924
39925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
39926   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
39927
39928   arg1 = (Dali::EncodedBufferImage *)jarg1;
39929   {
39930     try {
39931       delete arg1;
39932     } catch (std::out_of_range& e) {
39933       {
39934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39935       };
39936     } catch (std::exception& e) {
39937       {
39938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39939       };
39940     } catch (...) {
39941       {
39942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39943       };
39944     }
39945   }
39946 }
39947
39948
39949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
39950   void * jresult ;
39951   Dali::EncodedBufferImage *arg1 = 0 ;
39952   Dali::EncodedBufferImage *result = 0 ;
39953
39954   arg1 = (Dali::EncodedBufferImage *)jarg1;
39955   if (!arg1) {
39956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
39957     return 0;
39958   }
39959   {
39960     try {
39961       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
39962     } catch (std::out_of_range& e) {
39963       {
39964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39965       };
39966     } catch (std::exception& e) {
39967       {
39968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39969       };
39970     } catch (...) {
39971       {
39972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39973       };
39974     }
39975   }
39976   jresult = (void *)result;
39977   return jresult;
39978 }
39979
39980
39981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
39982   void * jresult ;
39983   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
39984   Dali::EncodedBufferImage *arg2 = 0 ;
39985   Dali::EncodedBufferImage *result = 0 ;
39986
39987   arg1 = (Dali::EncodedBufferImage *)jarg1;
39988   arg2 = (Dali::EncodedBufferImage *)jarg2;
39989   if (!arg2) {
39990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
39991     return 0;
39992   }
39993   {
39994     try {
39995       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
39996     } catch (std::out_of_range& e) {
39997       {
39998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39999       };
40000     } catch (std::exception& e) {
40001       {
40002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40003       };
40004     } catch (...) {
40005       {
40006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40007       };
40008     }
40009   }
40010   jresult = (void *)result;
40011   return jresult;
40012 }
40013
40014
40015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
40016   void * jresult ;
40017   Dali::NativeImage *result = 0 ;
40018
40019   {
40020     try {
40021       result = (Dali::NativeImage *)new Dali::NativeImage();
40022     } catch (std::out_of_range& e) {
40023       {
40024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40025       };
40026     } catch (std::exception& e) {
40027       {
40028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40029       };
40030     } catch (...) {
40031       {
40032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40033       };
40034     }
40035   }
40036   jresult = (void *)result;
40037   return jresult;
40038 }
40039
40040
40041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
40042   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40043
40044   arg1 = (Dali::NativeImage *)jarg1;
40045   {
40046     try {
40047       delete arg1;
40048     } catch (std::out_of_range& e) {
40049       {
40050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40051       };
40052     } catch (std::exception& e) {
40053       {
40054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40055       };
40056     } catch (...) {
40057       {
40058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40059       };
40060     }
40061   }
40062 }
40063
40064
40065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
40066   void * jresult ;
40067   Dali::NativeImage *arg1 = 0 ;
40068   Dali::NativeImage *result = 0 ;
40069
40070   arg1 = (Dali::NativeImage *)jarg1;
40071   if (!arg1) {
40072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
40073     return 0;
40074   }
40075   {
40076     try {
40077       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
40078     } catch (std::out_of_range& e) {
40079       {
40080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40081       };
40082     } catch (std::exception& e) {
40083       {
40084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40085       };
40086     } catch (...) {
40087       {
40088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40089       };
40090     }
40091   }
40092   jresult = (void *)result;
40093   return jresult;
40094 }
40095
40096
40097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
40098   void * jresult ;
40099   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40100   Dali::NativeImage *arg2 = 0 ;
40101   Dali::NativeImage *result = 0 ;
40102
40103   arg1 = (Dali::NativeImage *)jarg1;
40104   arg2 = (Dali::NativeImage *)jarg2;
40105   if (!arg2) {
40106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
40107     return 0;
40108   }
40109   {
40110     try {
40111       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
40112     } catch (std::out_of_range& e) {
40113       {
40114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40115       };
40116     } catch (std::exception& e) {
40117       {
40118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40119       };
40120     } catch (...) {
40121       {
40122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40123       };
40124     }
40125   }
40126   jresult = (void *)result;
40127   return jresult;
40128 }
40129
40130
40131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
40132   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40133
40134   arg1 = (Dali::NativeImage *)jarg1;
40135   {
40136     try {
40137       (arg1)->CreateGlTexture();
40138     } catch (std::out_of_range& e) {
40139       {
40140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40141       };
40142     } catch (std::exception& e) {
40143       {
40144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40145       };
40146     } catch (...) {
40147       {
40148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40149       };
40150     }
40151   }
40152 }
40153
40154
40155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
40156   void * jresult ;
40157   NativeImageInterface *arg1 = 0 ;
40158   Dali::NativeImage result;
40159
40160   arg1 = (NativeImageInterface *)jarg1;
40161   if (!arg1) {
40162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
40163     return 0;
40164   }
40165   {
40166     try {
40167       result = Dali::NativeImage::New(*arg1);
40168     } catch (std::out_of_range& e) {
40169       {
40170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40171       };
40172     } catch (std::exception& e) {
40173       {
40174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40175       };
40176     } catch (...) {
40177       {
40178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40179       };
40180     }
40181   }
40182   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
40183   return jresult;
40184 }
40185
40186
40187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
40188   void * jresult ;
40189   Dali::BaseHandle arg1 ;
40190   Dali::BaseHandle *argp1 ;
40191   Dali::NativeImage result;
40192
40193   argp1 = (Dali::BaseHandle *)jarg1;
40194   if (!argp1) {
40195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40196     return 0;
40197   }
40198   arg1 = *argp1;
40199   {
40200     try {
40201       result = Dali::NativeImage::DownCast(arg1);
40202     } catch (std::out_of_range& e) {
40203       {
40204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40205       };
40206     } catch (std::exception& e) {
40207       {
40208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40209       };
40210     } catch (...) {
40211       {
40212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40213       };
40214     }
40215   }
40216   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
40217   return jresult;
40218 }
40219
40220
40221 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
40222   char * jresult ;
40223   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40224   char *result = 0 ;
40225
40226   arg1 = (Dali::NativeImage *)jarg1;
40227   {
40228     try {
40229       result = (char *)(arg1)->GetCustomFragmentPreFix();
40230     } catch (std::out_of_range& e) {
40231       {
40232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40233       };
40234     } catch (std::exception& e) {
40235       {
40236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40237       };
40238     } catch (...) {
40239       {
40240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40241       };
40242     }
40243   }
40244   jresult = SWIG_csharp_string_callback((const char *)result);
40245   return jresult;
40246 }
40247
40248
40249 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
40250   char * jresult ;
40251   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40252   char *result = 0 ;
40253
40254   arg1 = (Dali::NativeImage *)jarg1;
40255   {
40256     try {
40257       result = (char *)(arg1)->GetCustomSamplerTypename();
40258     } catch (std::out_of_range& e) {
40259       {
40260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40261       };
40262     } catch (std::exception& e) {
40263       {
40264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40265       };
40266     } catch (...) {
40267       {
40268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40269       };
40270     }
40271   }
40272   jresult = SWIG_csharp_string_callback((const char *)result);
40273   return jresult;
40274 }
40275
40276
40277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
40278   unsigned int jresult ;
40279   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40280   bool result;
40281
40282   arg1 = (Dali::NativeImageInterface *)jarg1;
40283   {
40284     try {
40285       result = (bool)(arg1)->GlExtensionCreate();
40286     } catch (std::out_of_range& e) {
40287       {
40288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40289       };
40290     } catch (std::exception& e) {
40291       {
40292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40293       };
40294     } catch (...) {
40295       {
40296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40297       };
40298     }
40299   }
40300   jresult = result;
40301   return jresult;
40302 }
40303
40304
40305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
40306   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40307
40308   arg1 = (Dali::NativeImageInterface *)jarg1;
40309   {
40310     try {
40311       (arg1)->GlExtensionDestroy();
40312     } catch (std::out_of_range& e) {
40313       {
40314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40315       };
40316     } catch (std::exception& e) {
40317       {
40318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40319       };
40320     } catch (...) {
40321       {
40322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40323       };
40324     }
40325   }
40326 }
40327
40328
40329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
40330   unsigned int jresult ;
40331   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40332   unsigned int result;
40333
40334   arg1 = (Dali::NativeImageInterface *)jarg1;
40335   {
40336     try {
40337       result = (unsigned int)(arg1)->TargetTexture();
40338     } catch (std::out_of_range& e) {
40339       {
40340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40341       };
40342     } catch (std::exception& e) {
40343       {
40344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40345       };
40346     } catch (...) {
40347       {
40348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40349       };
40350     }
40351   }
40352   jresult = result;
40353   return jresult;
40354 }
40355
40356
40357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
40358   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40359
40360   arg1 = (Dali::NativeImageInterface *)jarg1;
40361   {
40362     try {
40363       (arg1)->PrepareTexture();
40364     } catch (std::out_of_range& e) {
40365       {
40366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40367       };
40368     } catch (std::exception& e) {
40369       {
40370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40371       };
40372     } catch (...) {
40373       {
40374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40375       };
40376     }
40377   }
40378 }
40379
40380
40381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
40382   unsigned int jresult ;
40383   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40384   unsigned int result;
40385
40386   arg1 = (Dali::NativeImageInterface *)jarg1;
40387   {
40388     try {
40389       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
40390     } catch (std::out_of_range& e) {
40391       {
40392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40393       };
40394     } catch (std::exception& e) {
40395       {
40396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40397       };
40398     } catch (...) {
40399       {
40400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40401       };
40402     }
40403   }
40404   jresult = result;
40405   return jresult;
40406 }
40407
40408
40409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
40410   unsigned int jresult ;
40411   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40412   unsigned int result;
40413
40414   arg1 = (Dali::NativeImageInterface *)jarg1;
40415   {
40416     try {
40417       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
40418     } catch (std::out_of_range& e) {
40419       {
40420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40421       };
40422     } catch (std::exception& e) {
40423       {
40424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40425       };
40426     } catch (...) {
40427       {
40428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40429       };
40430     }
40431   }
40432   jresult = result;
40433   return jresult;
40434 }
40435
40436
40437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
40438   unsigned int jresult ;
40439   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40440   bool result;
40441
40442   arg1 = (Dali::NativeImageInterface *)jarg1;
40443   {
40444     try {
40445       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
40446     } catch (std::out_of_range& e) {
40447       {
40448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40449       };
40450     } catch (std::exception& e) {
40451       {
40452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40453       };
40454     } catch (...) {
40455       {
40456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40457       };
40458     }
40459   }
40460   jresult = result;
40461   return jresult;
40462 }
40463
40464
40465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
40466   void * jresult ;
40467   std::string *arg1 = 0 ;
40468   Dali::ImageDimensions result;
40469
40470   if (!jarg1) {
40471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40472     return 0;
40473   }
40474   std::string arg1_str(jarg1);
40475   arg1 = &arg1_str;
40476   {
40477     try {
40478       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
40479     } catch (std::out_of_range& e) {
40480       {
40481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40482       };
40483     } catch (std::exception& e) {
40484       {
40485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40486       };
40487     } catch (...) {
40488       {
40489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40490       };
40491     }
40492   }
40493   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
40494
40495   //argout typemap for const std::string&
40496
40497   return jresult;
40498 }
40499
40500
40501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
40502   void * jresult ;
40503   Dali::ResourceImage *result = 0 ;
40504
40505   {
40506     try {
40507       result = (Dali::ResourceImage *)new Dali::ResourceImage();
40508     } catch (std::out_of_range& e) {
40509       {
40510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40511       };
40512     } catch (std::exception& e) {
40513       {
40514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40515       };
40516     } catch (...) {
40517       {
40518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40519       };
40520     }
40521   }
40522   jresult = (void *)result;
40523   return jresult;
40524 }
40525
40526
40527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
40528   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40529
40530   arg1 = (Dali::ResourceImage *)jarg1;
40531   {
40532     try {
40533       delete arg1;
40534     } catch (std::out_of_range& e) {
40535       {
40536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40537       };
40538     } catch (std::exception& e) {
40539       {
40540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40541       };
40542     } catch (...) {
40543       {
40544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40545       };
40546     }
40547   }
40548 }
40549
40550
40551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
40552   void * jresult ;
40553   Dali::ResourceImage *arg1 = 0 ;
40554   Dali::ResourceImage *result = 0 ;
40555
40556   arg1 = (Dali::ResourceImage *)jarg1;
40557   if (!arg1) {
40558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
40559     return 0;
40560   }
40561   {
40562     try {
40563       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
40564     } catch (std::out_of_range& e) {
40565       {
40566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40567       };
40568     } catch (std::exception& e) {
40569       {
40570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40571       };
40572     } catch (...) {
40573       {
40574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40575       };
40576     }
40577   }
40578   jresult = (void *)result;
40579   return jresult;
40580 }
40581
40582
40583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
40584   void * jresult ;
40585   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40586   Dali::ResourceImage *arg2 = 0 ;
40587   Dali::ResourceImage *result = 0 ;
40588
40589   arg1 = (Dali::ResourceImage *)jarg1;
40590   arg2 = (Dali::ResourceImage *)jarg2;
40591   if (!arg2) {
40592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
40593     return 0;
40594   }
40595   {
40596     try {
40597       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
40598     } catch (std::out_of_range& e) {
40599       {
40600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40601       };
40602     } catch (std::exception& e) {
40603       {
40604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40605       };
40606     } catch (...) {
40607       {
40608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40609       };
40610     }
40611   }
40612   jresult = (void *)result;
40613   return jresult;
40614 }
40615
40616
40617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
40618   void * jresult ;
40619   std::string *arg1 = 0 ;
40620   bool arg2 ;
40621   Dali::ResourceImage result;
40622
40623   if (!jarg1) {
40624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40625     return 0;
40626   }
40627   std::string arg1_str(jarg1);
40628   arg1 = &arg1_str;
40629   arg2 = jarg2 ? true : false;
40630   {
40631     try {
40632       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
40633     } catch (std::out_of_range& e) {
40634       {
40635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40636       };
40637     } catch (std::exception& e) {
40638       {
40639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40640       };
40641     } catch (...) {
40642       {
40643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40644       };
40645     }
40646   }
40647   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40648
40649   //argout typemap for const std::string&
40650
40651   return jresult;
40652 }
40653
40654
40655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
40656   void * jresult ;
40657   std::string *arg1 = 0 ;
40658   Dali::ResourceImage result;
40659
40660   if (!jarg1) {
40661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40662     return 0;
40663   }
40664   std::string arg1_str(jarg1);
40665   arg1 = &arg1_str;
40666   {
40667     try {
40668       result = Dali::ResourceImage::New((std::string const &)*arg1);
40669     } catch (std::out_of_range& e) {
40670       {
40671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40672       };
40673     } catch (std::exception& e) {
40674       {
40675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40676       };
40677     } catch (...) {
40678       {
40679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40680       };
40681     }
40682   }
40683   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40684
40685   //argout typemap for const std::string&
40686
40687   return jresult;
40688 }
40689
40690
40691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
40692   void * jresult ;
40693   std::string *arg1 = 0 ;
40694   Dali::ImageDimensions arg2 ;
40695   Dali::FittingMode::Type arg3 ;
40696   Dali::SamplingMode::Type arg4 ;
40697   bool arg5 ;
40698   Dali::ImageDimensions *argp2 ;
40699   Dali::ResourceImage result;
40700
40701   if (!jarg1) {
40702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40703     return 0;
40704   }
40705   std::string arg1_str(jarg1);
40706   arg1 = &arg1_str;
40707   argp2 = (Dali::ImageDimensions *)jarg2;
40708   if (!argp2) {
40709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40710     return 0;
40711   }
40712   arg2 = *argp2;
40713   arg3 = (Dali::FittingMode::Type)jarg3;
40714   arg4 = (Dali::SamplingMode::Type)jarg4;
40715   arg5 = jarg5 ? true : false;
40716   {
40717     try {
40718       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
40719     } catch (std::out_of_range& e) {
40720       {
40721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40722       };
40723     } catch (std::exception& e) {
40724       {
40725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40726       };
40727     } catch (...) {
40728       {
40729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40730       };
40731     }
40732   }
40733   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40734
40735   //argout typemap for const std::string&
40736
40737   return jresult;
40738 }
40739
40740
40741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
40742   void * jresult ;
40743   std::string *arg1 = 0 ;
40744   Dali::ImageDimensions arg2 ;
40745   Dali::FittingMode::Type arg3 ;
40746   Dali::SamplingMode::Type arg4 ;
40747   Dali::ImageDimensions *argp2 ;
40748   Dali::ResourceImage result;
40749
40750   if (!jarg1) {
40751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40752     return 0;
40753   }
40754   std::string arg1_str(jarg1);
40755   arg1 = &arg1_str;
40756   argp2 = (Dali::ImageDimensions *)jarg2;
40757   if (!argp2) {
40758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40759     return 0;
40760   }
40761   arg2 = *argp2;
40762   arg3 = (Dali::FittingMode::Type)jarg3;
40763   arg4 = (Dali::SamplingMode::Type)jarg4;
40764   {
40765     try {
40766       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
40767     } catch (std::out_of_range& e) {
40768       {
40769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40770       };
40771     } catch (std::exception& e) {
40772       {
40773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40774       };
40775     } catch (...) {
40776       {
40777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40778       };
40779     }
40780   }
40781   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40782
40783   //argout typemap for const std::string&
40784
40785   return jresult;
40786 }
40787
40788
40789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
40790   void * jresult ;
40791   std::string *arg1 = 0 ;
40792   Dali::ImageDimensions arg2 ;
40793   Dali::FittingMode::Type arg3 ;
40794   Dali::ImageDimensions *argp2 ;
40795   Dali::ResourceImage result;
40796
40797   if (!jarg1) {
40798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40799     return 0;
40800   }
40801   std::string arg1_str(jarg1);
40802   arg1 = &arg1_str;
40803   argp2 = (Dali::ImageDimensions *)jarg2;
40804   if (!argp2) {
40805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40806     return 0;
40807   }
40808   arg2 = *argp2;
40809   arg3 = (Dali::FittingMode::Type)jarg3;
40810   {
40811     try {
40812       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
40813     } catch (std::out_of_range& e) {
40814       {
40815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40816       };
40817     } catch (std::exception& e) {
40818       {
40819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40820       };
40821     } catch (...) {
40822       {
40823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40824       };
40825     }
40826   }
40827   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40828
40829   //argout typemap for const std::string&
40830
40831   return jresult;
40832 }
40833
40834
40835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
40836   void * jresult ;
40837   std::string *arg1 = 0 ;
40838   Dali::ImageDimensions arg2 ;
40839   Dali::ImageDimensions *argp2 ;
40840   Dali::ResourceImage result;
40841
40842   if (!jarg1) {
40843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40844     return 0;
40845   }
40846   std::string arg1_str(jarg1);
40847   arg1 = &arg1_str;
40848   argp2 = (Dali::ImageDimensions *)jarg2;
40849   if (!argp2) {
40850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40851     return 0;
40852   }
40853   arg2 = *argp2;
40854   {
40855     try {
40856       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
40857     } catch (std::out_of_range& e) {
40858       {
40859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40860       };
40861     } catch (std::exception& e) {
40862       {
40863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40864       };
40865     } catch (...) {
40866       {
40867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40868       };
40869     }
40870   }
40871   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40872
40873   //argout typemap for const std::string&
40874
40875   return jresult;
40876 }
40877
40878
40879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
40880   void * jresult ;
40881   Dali::BaseHandle arg1 ;
40882   Dali::BaseHandle *argp1 ;
40883   Dali::ResourceImage result;
40884
40885   argp1 = (Dali::BaseHandle *)jarg1;
40886   if (!argp1) {
40887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40888     return 0;
40889   }
40890   arg1 = *argp1;
40891   {
40892     try {
40893       result = Dali::ResourceImage::DownCast(arg1);
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::ResourceImage((const Dali::ResourceImage &)result);
40909   return jresult;
40910 }
40911
40912
40913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
40914   int jresult ;
40915   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40916   Dali::LoadingState result;
40917
40918   arg1 = (Dali::ResourceImage *)jarg1;
40919   {
40920     try {
40921       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
40922     } catch (std::out_of_range& e) {
40923       {
40924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40925       };
40926     } catch (std::exception& e) {
40927       {
40928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40929       };
40930     } catch (...) {
40931       {
40932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40933       };
40934     }
40935   }
40936   jresult = (int)result;
40937   return jresult;
40938 }
40939
40940
40941 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
40942   char * jresult ;
40943   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40944   std::string result;
40945
40946   arg1 = (Dali::ResourceImage *)jarg1;
40947   {
40948     try {
40949       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
40950     } catch (std::out_of_range& e) {
40951       {
40952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40953       };
40954     } catch (std::exception& e) {
40955       {
40956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40957       };
40958     } catch (...) {
40959       {
40960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40961       };
40962     }
40963   }
40964   jresult = SWIG_csharp_string_callback((&result)->c_str());
40965   return jresult;
40966 }
40967
40968
40969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
40970   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40971
40972   arg1 = (Dali::ResourceImage *)jarg1;
40973   {
40974     try {
40975       (arg1)->Reload();
40976     } catch (std::out_of_range& e) {
40977       {
40978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40979       };
40980     } catch (std::exception& e) {
40981       {
40982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40983       };
40984     } catch (...) {
40985       {
40986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40987       };
40988     }
40989   }
40990 }
40991
40992
40993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
40994   void * jresult ;
40995   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40996   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
40997
40998   arg1 = (Dali::ResourceImage *)jarg1;
40999   {
41000     try {
41001       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
41002     } catch (std::out_of_range& e) {
41003       {
41004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41005       };
41006     } catch (std::exception& e) {
41007       {
41008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41009       };
41010     } catch (...) {
41011       {
41012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41013       };
41014     }
41015   }
41016   jresult = (void *)result;
41017   return jresult;
41018 }
41019
41020
41021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
41022   void * jresult ;
41023   Dali::FrameBufferImage *result = 0 ;
41024
41025   {
41026     try {
41027       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
41028     } catch (std::out_of_range& e) {
41029       {
41030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41031       };
41032     } catch (std::exception& e) {
41033       {
41034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41035       };
41036     } catch (...) {
41037       {
41038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41039       };
41040     }
41041   }
41042   jresult = (void *)result;
41043   return jresult;
41044 }
41045
41046
41047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
41048   void * jresult ;
41049   unsigned int arg1 ;
41050   unsigned int arg2 ;
41051   Dali::Pixel::Format arg3 ;
41052   Dali::RenderBuffer::Format arg4 ;
41053   Dali::FrameBufferImage result;
41054
41055   arg1 = (unsigned int)jarg1;
41056   arg2 = (unsigned int)jarg2;
41057   arg3 = (Dali::Pixel::Format)jarg3;
41058   arg4 = (Dali::RenderBuffer::Format)jarg4;
41059   {
41060     try {
41061       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
41062     } catch (std::out_of_range& e) {
41063       {
41064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41065       };
41066     } catch (std::exception& e) {
41067       {
41068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41069       };
41070     } catch (...) {
41071       {
41072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41073       };
41074     }
41075   }
41076   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41077   return jresult;
41078 }
41079
41080
41081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41082   void * jresult ;
41083   unsigned int arg1 ;
41084   unsigned int arg2 ;
41085   Dali::Pixel::Format arg3 ;
41086   Dali::FrameBufferImage result;
41087
41088   arg1 = (unsigned int)jarg1;
41089   arg2 = (unsigned int)jarg2;
41090   arg3 = (Dali::Pixel::Format)jarg3;
41091   {
41092     try {
41093       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
41094     } catch (std::out_of_range& e) {
41095       {
41096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41097       };
41098     } catch (std::exception& e) {
41099       {
41100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41101       };
41102     } catch (...) {
41103       {
41104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41105       };
41106     }
41107   }
41108   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41109   return jresult;
41110 }
41111
41112
41113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
41114   void * jresult ;
41115   unsigned int arg1 ;
41116   unsigned int arg2 ;
41117   Dali::FrameBufferImage result;
41118
41119   arg1 = (unsigned int)jarg1;
41120   arg2 = (unsigned int)jarg2;
41121   {
41122     try {
41123       result = Dali::FrameBufferImage::New(arg1,arg2);
41124     } catch (std::out_of_range& e) {
41125       {
41126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41127       };
41128     } catch (std::exception& e) {
41129       {
41130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41131       };
41132     } catch (...) {
41133       {
41134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41135       };
41136     }
41137   }
41138   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41139   return jresult;
41140 }
41141
41142
41143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
41144   void * jresult ;
41145   unsigned int arg1 ;
41146   Dali::FrameBufferImage result;
41147
41148   arg1 = (unsigned int)jarg1;
41149   {
41150     try {
41151       result = Dali::FrameBufferImage::New(arg1);
41152     } catch (std::out_of_range& e) {
41153       {
41154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41155       };
41156     } catch (std::exception& e) {
41157       {
41158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41159       };
41160     } catch (...) {
41161       {
41162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41163       };
41164     }
41165   }
41166   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41167   return jresult;
41168 }
41169
41170
41171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
41172   void * jresult ;
41173   Dali::FrameBufferImage result;
41174
41175   {
41176     try {
41177       result = Dali::FrameBufferImage::New();
41178     } catch (std::out_of_range& e) {
41179       {
41180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41181       };
41182     } catch (std::exception& e) {
41183       {
41184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41185       };
41186     } catch (...) {
41187       {
41188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41189       };
41190     }
41191   }
41192   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41193   return jresult;
41194 }
41195
41196
41197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
41198   void * jresult ;
41199   Dali::NativeImageInterface *arg1 = 0 ;
41200   Dali::FrameBufferImage result;
41201
41202   arg1 = (Dali::NativeImageInterface *)jarg1;
41203   if (!arg1) {
41204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
41205     return 0;
41206   }
41207   {
41208     try {
41209       result = Dali::FrameBufferImage::New(*arg1);
41210     } catch (std::out_of_range& e) {
41211       {
41212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41213       };
41214     } catch (std::exception& e) {
41215       {
41216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41217       };
41218     } catch (...) {
41219       {
41220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41221       };
41222     }
41223   }
41224   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41225   return jresult;
41226 }
41227
41228
41229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
41230   void * jresult ;
41231   Dali::BaseHandle arg1 ;
41232   Dali::BaseHandle *argp1 ;
41233   Dali::FrameBufferImage result;
41234
41235   argp1 = (Dali::BaseHandle *)jarg1;
41236   if (!argp1) {
41237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41238     return 0;
41239   }
41240   arg1 = *argp1;
41241   {
41242     try {
41243       result = Dali::FrameBufferImage::DownCast(arg1);
41244     } catch (std::out_of_range& e) {
41245       {
41246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41247       };
41248     } catch (std::exception& e) {
41249       {
41250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41251       };
41252     } catch (...) {
41253       {
41254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41255       };
41256     }
41257   }
41258   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41259   return jresult;
41260 }
41261
41262
41263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
41264   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
41265
41266   arg1 = (Dali::FrameBufferImage *)jarg1;
41267   {
41268     try {
41269       delete arg1;
41270     } catch (std::out_of_range& e) {
41271       {
41272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41273       };
41274     } catch (std::exception& e) {
41275       {
41276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41277       };
41278     } catch (...) {
41279       {
41280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41281       };
41282     }
41283   }
41284 }
41285
41286
41287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
41288   void * jresult ;
41289   Dali::FrameBufferImage *arg1 = 0 ;
41290   Dali::FrameBufferImage *result = 0 ;
41291
41292   arg1 = (Dali::FrameBufferImage *)jarg1;
41293   if (!arg1) {
41294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
41295     return 0;
41296   }
41297   {
41298     try {
41299       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
41300     } catch (std::out_of_range& e) {
41301       {
41302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41303       };
41304     } catch (std::exception& e) {
41305       {
41306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41307       };
41308     } catch (...) {
41309       {
41310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41311       };
41312     }
41313   }
41314   jresult = (void *)result;
41315   return jresult;
41316 }
41317
41318
41319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
41320   void * jresult ;
41321   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
41322   Dali::FrameBufferImage *arg2 = 0 ;
41323   Dali::FrameBufferImage *result = 0 ;
41324
41325   arg1 = (Dali::FrameBufferImage *)jarg1;
41326   arg2 = (Dali::FrameBufferImage *)jarg2;
41327   if (!arg2) {
41328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
41329     return 0;
41330   }
41331   {
41332     try {
41333       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
41334     } catch (std::out_of_range& e) {
41335       {
41336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41337       };
41338     } catch (std::exception& e) {
41339       {
41340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41341       };
41342     } catch (...) {
41343       {
41344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41345       };
41346     }
41347   }
41348   jresult = (void *)result;
41349   return jresult;
41350 }
41351
41352
41353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
41354   void * jresult ;
41355   Dali::NinePatchImage *result = 0 ;
41356
41357   {
41358     try {
41359       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
41360     } catch (std::out_of_range& e) {
41361       {
41362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41363       };
41364     } catch (std::exception& e) {
41365       {
41366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41367       };
41368     } catch (...) {
41369       {
41370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41371       };
41372     }
41373   }
41374   jresult = (void *)result;
41375   return jresult;
41376 }
41377
41378
41379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
41380   void * jresult ;
41381   std::string *arg1 = 0 ;
41382   Dali::NinePatchImage result;
41383
41384   if (!jarg1) {
41385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41386     return 0;
41387   }
41388   std::string arg1_str(jarg1);
41389   arg1 = &arg1_str;
41390   {
41391     try {
41392       result = Dali::NinePatchImage::New((std::string const &)*arg1);
41393     } catch (std::out_of_range& e) {
41394       {
41395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41396       };
41397     } catch (std::exception& e) {
41398       {
41399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41400       };
41401     } catch (...) {
41402       {
41403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41404       };
41405     }
41406   }
41407   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
41408
41409   //argout typemap for const std::string&
41410
41411   return jresult;
41412 }
41413
41414
41415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
41416   void * jresult ;
41417   Dali::BaseHandle arg1 ;
41418   Dali::BaseHandle *argp1 ;
41419   Dali::NinePatchImage result;
41420
41421   argp1 = (Dali::BaseHandle *)jarg1;
41422   if (!argp1) {
41423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41424     return 0;
41425   }
41426   arg1 = *argp1;
41427   {
41428     try {
41429       result = Dali::NinePatchImage::DownCast(arg1);
41430     } catch (std::out_of_range& e) {
41431       {
41432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41433       };
41434     } catch (std::exception& e) {
41435       {
41436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41437       };
41438     } catch (...) {
41439       {
41440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41441       };
41442     }
41443   }
41444   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
41445   return jresult;
41446 }
41447
41448
41449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
41450   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41451
41452   arg1 = (Dali::NinePatchImage *)jarg1;
41453   {
41454     try {
41455       delete arg1;
41456     } catch (std::out_of_range& e) {
41457       {
41458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41459       };
41460     } catch (std::exception& e) {
41461       {
41462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41463       };
41464     } catch (...) {
41465       {
41466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41467       };
41468     }
41469   }
41470 }
41471
41472
41473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
41474   void * jresult ;
41475   Dali::NinePatchImage *arg1 = 0 ;
41476   Dali::NinePatchImage *result = 0 ;
41477
41478   arg1 = (Dali::NinePatchImage *)jarg1;
41479   if (!arg1) {
41480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
41481     return 0;
41482   }
41483   {
41484     try {
41485       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
41486     } catch (std::out_of_range& e) {
41487       {
41488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41489       };
41490     } catch (std::exception& e) {
41491       {
41492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41493       };
41494     } catch (...) {
41495       {
41496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41497       };
41498     }
41499   }
41500   jresult = (void *)result;
41501   return jresult;
41502 }
41503
41504
41505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
41506   void * jresult ;
41507   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41508   Dali::NinePatchImage *arg2 = 0 ;
41509   Dali::NinePatchImage *result = 0 ;
41510
41511   arg1 = (Dali::NinePatchImage *)jarg1;
41512   arg2 = (Dali::NinePatchImage *)jarg2;
41513   if (!arg2) {
41514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
41515     return 0;
41516   }
41517   {
41518     try {
41519       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
41520     } catch (std::out_of_range& e) {
41521       {
41522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41523       };
41524     } catch (std::exception& e) {
41525       {
41526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41527       };
41528     } catch (...) {
41529       {
41530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41531       };
41532     }
41533   }
41534   jresult = (void *)result;
41535   return jresult;
41536 }
41537
41538
41539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
41540   void * jresult ;
41541   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41542   Dali::Vector4 result;
41543
41544   arg1 = (Dali::NinePatchImage *)jarg1;
41545   {
41546     try {
41547       result = (arg1)->GetStretchBorders();
41548     } catch (std::out_of_range& e) {
41549       {
41550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41551       };
41552     } catch (std::exception& e) {
41553       {
41554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41555       };
41556     } catch (...) {
41557       {
41558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41559       };
41560     }
41561   }
41562   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
41563   return jresult;
41564 }
41565
41566
41567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
41568   void * jresult ;
41569   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41570   Dali::NinePatchImage::StretchRanges *result = 0 ;
41571
41572   arg1 = (Dali::NinePatchImage *)jarg1;
41573   {
41574     try {
41575       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
41576     } catch (std::out_of_range& e) {
41577       {
41578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41579       };
41580     } catch (std::exception& e) {
41581       {
41582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41583       };
41584     } catch (...) {
41585       {
41586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41587       };
41588     }
41589   }
41590   jresult = (void *)result;
41591   return jresult;
41592 }
41593
41594
41595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
41596   void * jresult ;
41597   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41598   Dali::NinePatchImage::StretchRanges *result = 0 ;
41599
41600   arg1 = (Dali::NinePatchImage *)jarg1;
41601   {
41602     try {
41603       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
41604     } catch (std::out_of_range& e) {
41605       {
41606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41607       };
41608     } catch (std::exception& e) {
41609       {
41610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41611       };
41612     } catch (...) {
41613       {
41614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41615       };
41616     }
41617   }
41618   jresult = (void *)result;
41619   return jresult;
41620 }
41621
41622
41623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
41624   void * jresult ;
41625   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41626   Dali::Rect< int > result;
41627
41628   arg1 = (Dali::NinePatchImage *)jarg1;
41629   {
41630     try {
41631       result = (arg1)->GetChildRectangle();
41632     } catch (std::out_of_range& e) {
41633       {
41634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41635       };
41636     } catch (std::exception& e) {
41637       {
41638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41639       };
41640     } catch (...) {
41641       {
41642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41643       };
41644     }
41645   }
41646   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
41647   return jresult;
41648 }
41649
41650
41651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
41652   void * jresult ;
41653   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41654   Dali::BufferImage result;
41655
41656   arg1 = (Dali::NinePatchImage *)jarg1;
41657   {
41658     try {
41659       result = (arg1)->CreateCroppedBufferImage();
41660     } catch (std::out_of_range& e) {
41661       {
41662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41663       };
41664     } catch (std::exception& e) {
41665       {
41666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41667       };
41668     } catch (...) {
41669       {
41670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41671       };
41672     }
41673   }
41674   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41675   return jresult;
41676 }
41677
41678
41679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
41680   unsigned int jresult ;
41681   std::string *arg1 = 0 ;
41682   bool result;
41683
41684   if (!jarg1) {
41685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41686     return 0;
41687   }
41688   std::string arg1_str(jarg1);
41689   arg1 = &arg1_str;
41690   {
41691     try {
41692       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
41693     } catch (std::out_of_range& e) {
41694       {
41695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41696       };
41697     } catch (std::exception& e) {
41698       {
41699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41700       };
41701     } catch (...) {
41702       {
41703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41704       };
41705     }
41706   }
41707   jresult = result;
41708
41709   //argout typemap for const std::string&
41710
41711   return jresult;
41712 }
41713
41714
41715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
41716   int jresult ;
41717   int result;
41718
41719   result = (int)Dali::CameraActor::Property::TYPE;
41720   jresult = (int)result;
41721   return jresult;
41722 }
41723
41724
41725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
41726   int jresult ;
41727   int result;
41728
41729   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
41730   jresult = (int)result;
41731   return jresult;
41732 }
41733
41734
41735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
41736   int jresult ;
41737   int result;
41738
41739   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
41740   jresult = (int)result;
41741   return jresult;
41742 }
41743
41744
41745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
41746   int jresult ;
41747   int result;
41748
41749   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
41750   jresult = (int)result;
41751   return jresult;
41752 }
41753
41754
41755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
41756   int jresult ;
41757   int result;
41758
41759   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
41760   jresult = (int)result;
41761   return jresult;
41762 }
41763
41764
41765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
41766   int jresult ;
41767   int result;
41768
41769   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
41770   jresult = (int)result;
41771   return jresult;
41772 }
41773
41774
41775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
41776   int jresult ;
41777   int result;
41778
41779   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
41780   jresult = (int)result;
41781   return jresult;
41782 }
41783
41784
41785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
41786   int jresult ;
41787   int result;
41788
41789   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
41790   jresult = (int)result;
41791   return jresult;
41792 }
41793
41794
41795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
41796   int jresult ;
41797   int result;
41798
41799   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
41800   jresult = (int)result;
41801   return jresult;
41802 }
41803
41804
41805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
41806   int jresult ;
41807   int result;
41808
41809   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
41810   jresult = (int)result;
41811   return jresult;
41812 }
41813
41814
41815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
41816   int jresult ;
41817   int result;
41818
41819   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
41820   jresult = (int)result;
41821   return jresult;
41822 }
41823
41824
41825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
41826   int jresult ;
41827   int result;
41828
41829   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
41830   jresult = (int)result;
41831   return jresult;
41832 }
41833
41834
41835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
41836   int jresult ;
41837   int result;
41838
41839   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
41840   jresult = (int)result;
41841   return jresult;
41842 }
41843
41844
41845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
41846   int jresult ;
41847   int result;
41848
41849   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
41850   jresult = (int)result;
41851   return jresult;
41852 }
41853
41854
41855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
41856   void * jresult ;
41857   Dali::CameraActor::Property *result = 0 ;
41858
41859   {
41860     try {
41861       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
41862     } catch (std::out_of_range& e) {
41863       {
41864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41865       };
41866     } catch (std::exception& e) {
41867       {
41868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41869       };
41870     } catch (...) {
41871       {
41872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41873       };
41874     }
41875   }
41876   jresult = (void *)result;
41877   return jresult;
41878 }
41879
41880
41881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
41882   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
41883
41884   arg1 = (Dali::CameraActor::Property *)jarg1;
41885   {
41886     try {
41887       delete arg1;
41888     } catch (std::out_of_range& e) {
41889       {
41890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41891       };
41892     } catch (std::exception& e) {
41893       {
41894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41895       };
41896     } catch (...) {
41897       {
41898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41899       };
41900     }
41901   }
41902 }
41903
41904
41905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
41906   void * jresult ;
41907   Dali::CameraActor *result = 0 ;
41908
41909   {
41910     try {
41911       result = (Dali::CameraActor *)new Dali::CameraActor();
41912     } catch (std::out_of_range& e) {
41913       {
41914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41915       };
41916     } catch (std::exception& e) {
41917       {
41918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41919       };
41920     } catch (...) {
41921       {
41922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41923       };
41924     }
41925   }
41926   jresult = (void *)result;
41927   return jresult;
41928 }
41929
41930
41931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
41932   void * jresult ;
41933   Dali::CameraActor result;
41934
41935   {
41936     try {
41937       result = Dali::CameraActor::New();
41938     } catch (std::out_of_range& e) {
41939       {
41940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41941       };
41942     } catch (std::exception& e) {
41943       {
41944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41945       };
41946     } catch (...) {
41947       {
41948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41949       };
41950     }
41951   }
41952   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
41953   return jresult;
41954 }
41955
41956
41957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
41958   void * jresult ;
41959   Dali::Size *arg1 = 0 ;
41960   Dali::CameraActor result;
41961
41962   arg1 = (Dali::Size *)jarg1;
41963   if (!arg1) {
41964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
41965     return 0;
41966   }
41967   {
41968     try {
41969       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
41970     } catch (std::out_of_range& e) {
41971       {
41972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41973       };
41974     } catch (std::exception& e) {
41975       {
41976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41977       };
41978     } catch (...) {
41979       {
41980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41981       };
41982     }
41983   }
41984   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
41985   return jresult;
41986 }
41987
41988
41989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
41990   void * jresult ;
41991   Dali::BaseHandle arg1 ;
41992   Dali::BaseHandle *argp1 ;
41993   Dali::CameraActor result;
41994
41995   argp1 = (Dali::BaseHandle *)jarg1;
41996   if (!argp1) {
41997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41998     return 0;
41999   }
42000   arg1 = *argp1;
42001   {
42002     try {
42003       result = Dali::CameraActor::DownCast(arg1);
42004     } catch (std::out_of_range& e) {
42005       {
42006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42007       };
42008     } catch (std::exception& e) {
42009       {
42010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42011       };
42012     } catch (...) {
42013       {
42014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42015       };
42016     }
42017   }
42018   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
42019   return jresult;
42020 }
42021
42022
42023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
42024   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42025
42026   arg1 = (Dali::CameraActor *)jarg1;
42027   {
42028     try {
42029       delete arg1;
42030     } catch (std::out_of_range& e) {
42031       {
42032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42033       };
42034     } catch (std::exception& e) {
42035       {
42036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42037       };
42038     } catch (...) {
42039       {
42040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42041       };
42042     }
42043   }
42044 }
42045
42046
42047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
42048   void * jresult ;
42049   Dali::CameraActor *arg1 = 0 ;
42050   Dali::CameraActor *result = 0 ;
42051
42052   arg1 = (Dali::CameraActor *)jarg1;
42053   if (!arg1) {
42054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
42055     return 0;
42056   }
42057   {
42058     try {
42059       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
42060     } catch (std::out_of_range& e) {
42061       {
42062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42063       };
42064     } catch (std::exception& e) {
42065       {
42066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42067       };
42068     } catch (...) {
42069       {
42070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42071       };
42072     }
42073   }
42074   jresult = (void *)result;
42075   return jresult;
42076 }
42077
42078
42079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
42080   void * jresult ;
42081   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42082   Dali::CameraActor *arg2 = 0 ;
42083   Dali::CameraActor *result = 0 ;
42084
42085   arg1 = (Dali::CameraActor *)jarg1;
42086   arg2 = (Dali::CameraActor *)jarg2;
42087   if (!arg2) {
42088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
42089     return 0;
42090   }
42091   {
42092     try {
42093       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
42094     } catch (std::out_of_range& e) {
42095       {
42096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42097       };
42098     } catch (std::exception& e) {
42099       {
42100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42101       };
42102     } catch (...) {
42103       {
42104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42105       };
42106     }
42107   }
42108   jresult = (void *)result;
42109   return jresult;
42110 }
42111
42112
42113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
42114   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42115   Dali::Camera::Type arg2 ;
42116
42117   arg1 = (Dali::CameraActor *)jarg1;
42118   arg2 = (Dali::Camera::Type)jarg2;
42119   {
42120     try {
42121       (arg1)->SetType(arg2);
42122     } catch (std::out_of_range& e) {
42123       {
42124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42125       };
42126     } catch (std::exception& e) {
42127       {
42128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42129       };
42130     } catch (...) {
42131       {
42132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42133       };
42134     }
42135   }
42136 }
42137
42138
42139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
42140   int jresult ;
42141   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42142   Dali::Camera::Type result;
42143
42144   arg1 = (Dali::CameraActor *)jarg1;
42145   {
42146     try {
42147       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
42148     } catch (std::out_of_range& e) {
42149       {
42150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42151       };
42152     } catch (std::exception& e) {
42153       {
42154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42155       };
42156     } catch (...) {
42157       {
42158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42159       };
42160     }
42161   }
42162   jresult = (int)result;
42163   return jresult;
42164 }
42165
42166
42167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
42168   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42169   Dali::Camera::ProjectionMode arg2 ;
42170
42171   arg1 = (Dali::CameraActor *)jarg1;
42172   arg2 = (Dali::Camera::ProjectionMode)jarg2;
42173   {
42174     try {
42175       (arg1)->SetProjectionMode(arg2);
42176     } catch (std::out_of_range& e) {
42177       {
42178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42179       };
42180     } catch (std::exception& e) {
42181       {
42182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42183       };
42184     } catch (...) {
42185       {
42186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42187       };
42188     }
42189   }
42190 }
42191
42192
42193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
42194   int jresult ;
42195   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42196   Dali::Camera::ProjectionMode result;
42197
42198   arg1 = (Dali::CameraActor *)jarg1;
42199   {
42200     try {
42201       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
42202     } catch (std::out_of_range& e) {
42203       {
42204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42205       };
42206     } catch (std::exception& e) {
42207       {
42208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42209       };
42210     } catch (...) {
42211       {
42212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42213       };
42214     }
42215   }
42216   jresult = (int)result;
42217   return jresult;
42218 }
42219
42220
42221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
42222   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42223   float arg2 ;
42224
42225   arg1 = (Dali::CameraActor *)jarg1;
42226   arg2 = (float)jarg2;
42227   {
42228     try {
42229       (arg1)->SetFieldOfView(arg2);
42230     } catch (std::out_of_range& e) {
42231       {
42232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42233       };
42234     } catch (std::exception& e) {
42235       {
42236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42237       };
42238     } catch (...) {
42239       {
42240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42241       };
42242     }
42243   }
42244 }
42245
42246
42247 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
42248   float jresult ;
42249   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42250   float result;
42251
42252   arg1 = (Dali::CameraActor *)jarg1;
42253   {
42254     try {
42255       result = (float)(arg1)->GetFieldOfView();
42256     } catch (std::out_of_range& e) {
42257       {
42258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42259       };
42260     } catch (std::exception& e) {
42261       {
42262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42263       };
42264     } catch (...) {
42265       {
42266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42267       };
42268     }
42269   }
42270   jresult = result;
42271   return jresult;
42272 }
42273
42274
42275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
42276   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42277   float arg2 ;
42278
42279   arg1 = (Dali::CameraActor *)jarg1;
42280   arg2 = (float)jarg2;
42281   {
42282     try {
42283       (arg1)->SetAspectRatio(arg2);
42284     } catch (std::out_of_range& e) {
42285       {
42286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42287       };
42288     } catch (std::exception& e) {
42289       {
42290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42291       };
42292     } catch (...) {
42293       {
42294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42295       };
42296     }
42297   }
42298 }
42299
42300
42301 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
42302   float jresult ;
42303   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42304   float result;
42305
42306   arg1 = (Dali::CameraActor *)jarg1;
42307   {
42308     try {
42309       result = (float)(arg1)->GetAspectRatio();
42310     } catch (std::out_of_range& e) {
42311       {
42312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42313       };
42314     } catch (std::exception& e) {
42315       {
42316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42317       };
42318     } catch (...) {
42319       {
42320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42321       };
42322     }
42323   }
42324   jresult = result;
42325   return jresult;
42326 }
42327
42328
42329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
42330   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42331   float arg2 ;
42332
42333   arg1 = (Dali::CameraActor *)jarg1;
42334   arg2 = (float)jarg2;
42335   {
42336     try {
42337       (arg1)->SetNearClippingPlane(arg2);
42338     } catch (std::out_of_range& e) {
42339       {
42340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42341       };
42342     } catch (std::exception& e) {
42343       {
42344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42345       };
42346     } catch (...) {
42347       {
42348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42349       };
42350     }
42351   }
42352 }
42353
42354
42355 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
42356   float jresult ;
42357   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42358   float result;
42359
42360   arg1 = (Dali::CameraActor *)jarg1;
42361   {
42362     try {
42363       result = (float)(arg1)->GetNearClippingPlane();
42364     } catch (std::out_of_range& e) {
42365       {
42366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42367       };
42368     } catch (std::exception& e) {
42369       {
42370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42371       };
42372     } catch (...) {
42373       {
42374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42375       };
42376     }
42377   }
42378   jresult = result;
42379   return jresult;
42380 }
42381
42382
42383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
42384   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42385   float arg2 ;
42386
42387   arg1 = (Dali::CameraActor *)jarg1;
42388   arg2 = (float)jarg2;
42389   {
42390     try {
42391       (arg1)->SetFarClippingPlane(arg2);
42392     } catch (std::out_of_range& e) {
42393       {
42394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42395       };
42396     } catch (std::exception& e) {
42397       {
42398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42399       };
42400     } catch (...) {
42401       {
42402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42403       };
42404     }
42405   }
42406 }
42407
42408
42409 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
42410   float jresult ;
42411   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42412   float result;
42413
42414   arg1 = (Dali::CameraActor *)jarg1;
42415   {
42416     try {
42417       result = (float)(arg1)->GetFarClippingPlane();
42418     } catch (std::out_of_range& e) {
42419       {
42420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42421       };
42422     } catch (std::exception& e) {
42423       {
42424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42425       };
42426     } catch (...) {
42427       {
42428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42429       };
42430     }
42431   }
42432   jresult = result;
42433   return jresult;
42434 }
42435
42436
42437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
42438   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42439   Dali::Vector3 *arg2 = 0 ;
42440
42441   arg1 = (Dali::CameraActor *)jarg1;
42442   arg2 = (Dali::Vector3 *)jarg2;
42443   if (!arg2) {
42444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42445     return ;
42446   }
42447   {
42448     try {
42449       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
42450     } catch (std::out_of_range& e) {
42451       {
42452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42453       };
42454     } catch (std::exception& e) {
42455       {
42456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42457       };
42458     } catch (...) {
42459       {
42460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42461       };
42462     }
42463   }
42464 }
42465
42466
42467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
42468   void * jresult ;
42469   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42470   Dali::Vector3 result;
42471
42472   arg1 = (Dali::CameraActor *)jarg1;
42473   {
42474     try {
42475       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
42476     } catch (std::out_of_range& e) {
42477       {
42478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42479       };
42480     } catch (std::exception& e) {
42481       {
42482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42483       };
42484     } catch (...) {
42485       {
42486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42487       };
42488     }
42489   }
42490   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
42491   return jresult;
42492 }
42493
42494
42495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
42496   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42497   bool arg2 ;
42498
42499   arg1 = (Dali::CameraActor *)jarg1;
42500   arg2 = jarg2 ? true : false;
42501   {
42502     try {
42503       (arg1)->SetInvertYAxis(arg2);
42504     } catch (std::out_of_range& e) {
42505       {
42506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42507       };
42508     } catch (std::exception& e) {
42509       {
42510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42511       };
42512     } catch (...) {
42513       {
42514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42515       };
42516     }
42517   }
42518 }
42519
42520
42521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
42522   unsigned int jresult ;
42523   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42524   bool result;
42525
42526   arg1 = (Dali::CameraActor *)jarg1;
42527   {
42528     try {
42529       result = (bool)(arg1)->GetInvertYAxis();
42530     } catch (std::out_of_range& e) {
42531       {
42532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42533       };
42534     } catch (std::exception& e) {
42535       {
42536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42537       };
42538     } catch (...) {
42539       {
42540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42541       };
42542     }
42543   }
42544   jresult = result;
42545   return jresult;
42546 }
42547
42548
42549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
42550   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42551   Dali::Size *arg2 = 0 ;
42552
42553   arg1 = (Dali::CameraActor *)jarg1;
42554   arg2 = (Dali::Size *)jarg2;
42555   if (!arg2) {
42556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
42557     return ;
42558   }
42559   {
42560     try {
42561       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
42562     } catch (std::out_of_range& e) {
42563       {
42564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42565       };
42566     } catch (std::exception& e) {
42567       {
42568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42569       };
42570     } catch (...) {
42571       {
42572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42573       };
42574     }
42575   }
42576 }
42577
42578
42579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
42580   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42581   Dali::Size *arg2 = 0 ;
42582
42583   arg1 = (Dali::CameraActor *)jarg1;
42584   arg2 = (Dali::Size *)jarg2;
42585   if (!arg2) {
42586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
42587     return ;
42588   }
42589   {
42590     try {
42591       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
42592     } catch (std::out_of_range& e) {
42593       {
42594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42595       };
42596     } catch (std::exception& e) {
42597       {
42598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42599       };
42600     } catch (...) {
42601       {
42602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42603       };
42604     }
42605   }
42606 }
42607
42608
42609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
42610   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42611   float arg2 ;
42612   float arg3 ;
42613   float arg4 ;
42614   float arg5 ;
42615   float arg6 ;
42616   float arg7 ;
42617
42618   arg1 = (Dali::CameraActor *)jarg1;
42619   arg2 = (float)jarg2;
42620   arg3 = (float)jarg3;
42621   arg4 = (float)jarg4;
42622   arg5 = (float)jarg5;
42623   arg6 = (float)jarg6;
42624   arg7 = (float)jarg7;
42625   {
42626     try {
42627       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
42628     } catch (std::out_of_range& e) {
42629       {
42630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42631       };
42632     } catch (std::exception& e) {
42633       {
42634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42635       };
42636     } catch (...) {
42637       {
42638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42639       };
42640     }
42641   }
42642 }
42643
42644
42645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
42646   void * jresult ;
42647   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42648
42649   {
42650     try {
42651       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
42652     } catch (std::out_of_range& e) {
42653       {
42654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42655       };
42656     } catch (std::exception& e) {
42657       {
42658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42659       };
42660     } catch (...) {
42661       {
42662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42663       };
42664     }
42665   }
42666   jresult = (void *)result;
42667   return jresult;
42668 }
42669
42670
42671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
42672   void * jresult ;
42673   std::string arg1 ;
42674   Dali::Property::Value arg2 ;
42675   Dali::Property::Value *argp2 ;
42676   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42677
42678   if (!jarg1) {
42679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42680     return 0;
42681   }
42682   (&arg1)->assign(jarg1);
42683   argp2 = (Dali::Property::Value *)jarg2;
42684   if (!argp2) {
42685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42686     return 0;
42687   }
42688   arg2 = *argp2;
42689   {
42690     try {
42691       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
42692     } catch (std::out_of_range& e) {
42693       {
42694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42695       };
42696     } catch (std::exception& e) {
42697       {
42698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42699       };
42700     } catch (...) {
42701       {
42702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42703       };
42704     }
42705   }
42706   jresult = (void *)result;
42707   return jresult;
42708 }
42709
42710
42711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
42712   void * jresult ;
42713   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
42714   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42715
42716   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42717   if (!arg1) {
42718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
42719     return 0;
42720   }
42721   {
42722     try {
42723       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);
42724     } catch (std::out_of_range& e) {
42725       {
42726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42727       };
42728     } catch (std::exception& e) {
42729       {
42730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42731       };
42732     } catch (...) {
42733       {
42734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42735       };
42736     }
42737   }
42738   jresult = (void *)result;
42739   return jresult;
42740 }
42741
42742
42743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
42744   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42745   std::string *arg2 = 0 ;
42746
42747   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42748   if (!jarg2) {
42749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42750     return ;
42751   }
42752   std::string arg2_str(jarg2);
42753   arg2 = &arg2_str;
42754   if (arg1) (arg1)->first = *arg2;
42755
42756   //argout typemap for const std::string&
42757
42758 }
42759
42760
42761 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
42762   char * jresult ;
42763   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42764   std::string *result = 0 ;
42765
42766   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42767   result = (std::string *) & ((arg1)->first);
42768   jresult = SWIG_csharp_string_callback(result->c_str());
42769   return jresult;
42770 }
42771
42772
42773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
42774   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42775   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
42776
42777   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42778   arg2 = (Dali::Property::Value *)jarg2;
42779   if (arg1) (arg1)->second = *arg2;
42780 }
42781
42782
42783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
42784   void * jresult ;
42785   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42786   Dali::Property::Value *result = 0 ;
42787
42788   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42789   result = (Dali::Property::Value *)& ((arg1)->second);
42790   jresult = (void *)result;
42791   return jresult;
42792 }
42793
42794
42795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
42796   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42797
42798   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42799   {
42800     try {
42801       delete arg1;
42802     } catch (std::out_of_range& e) {
42803       {
42804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42805       };
42806     } catch (std::exception& e) {
42807       {
42808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42809       };
42810     } catch (...) {
42811       {
42812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42813       };
42814     }
42815   }
42816 }
42817
42818
42819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
42820   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42821
42822   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42823   {
42824     try {
42825       (arg1)->clear();
42826     } catch (std::out_of_range& e) {
42827       {
42828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42829       };
42830     } catch (std::exception& e) {
42831       {
42832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42833       };
42834     } catch (...) {
42835       {
42836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42837       };
42838     }
42839   }
42840 }
42841
42842
42843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
42844   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42845   Dali::TouchPoint *arg2 = 0 ;
42846
42847   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42848   arg2 = (Dali::TouchPoint *)jarg2;
42849   if (!arg2) {
42850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
42851     return ;
42852   }
42853   {
42854     try {
42855       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
42856     } catch (std::out_of_range& e) {
42857       {
42858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42859       };
42860     } catch (std::exception& e) {
42861       {
42862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42863       };
42864     } catch (...) {
42865       {
42866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42867       };
42868     }
42869   }
42870 }
42871
42872
42873 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
42874   unsigned long jresult ;
42875   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42876   std::vector< Dali::TouchPoint >::size_type result;
42877
42878   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42879   {
42880     try {
42881       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
42882     } catch (std::out_of_range& e) {
42883       {
42884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42885       };
42886     } catch (std::exception& e) {
42887       {
42888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42889       };
42890     } catch (...) {
42891       {
42892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42893       };
42894     }
42895   }
42896   jresult = (unsigned long)result;
42897   return jresult;
42898 }
42899
42900
42901 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
42902   unsigned long jresult ;
42903   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42904   std::vector< Dali::TouchPoint >::size_type result;
42905
42906   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42907   {
42908     try {
42909       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
42910     } catch (std::out_of_range& e) {
42911       {
42912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42913       };
42914     } catch (std::exception& e) {
42915       {
42916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42917       };
42918     } catch (...) {
42919       {
42920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42921       };
42922     }
42923   }
42924   jresult = (unsigned long)result;
42925   return jresult;
42926 }
42927
42928
42929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
42930   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42931   std::vector< Dali::TouchPoint >::size_type arg2 ;
42932
42933   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42934   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
42935   {
42936     try {
42937       (arg1)->reserve(arg2);
42938     } catch (std::out_of_range& e) {
42939       {
42940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42941       };
42942     } catch (std::exception& e) {
42943       {
42944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42945       };
42946     } catch (...) {
42947       {
42948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42949       };
42950     }
42951   }
42952 }
42953
42954
42955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
42956   void * jresult ;
42957   std::vector< Dali::TouchPoint > *result = 0 ;
42958
42959   {
42960     try {
42961       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
42962     } catch (std::out_of_range& e) {
42963       {
42964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42965       };
42966     } catch (std::exception& e) {
42967       {
42968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42969       };
42970     } catch (...) {
42971       {
42972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42973       };
42974     }
42975   }
42976   jresult = (void *)result;
42977   return jresult;
42978 }
42979
42980
42981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
42982   void * jresult ;
42983   std::vector< Dali::TouchPoint > *arg1 = 0 ;
42984   std::vector< Dali::TouchPoint > *result = 0 ;
42985
42986   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42987   if (!arg1) {
42988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
42989     return 0;
42990   }
42991   {
42992     try {
42993       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
42994     } catch (std::out_of_range& e) {
42995       {
42996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42997       };
42998     } catch (std::exception& e) {
42999       {
43000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43001       };
43002     } catch (...) {
43003       {
43004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43005       };
43006     }
43007   }
43008   jresult = (void *)result;
43009   return jresult;
43010 }
43011
43012
43013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
43014   void * jresult ;
43015   int arg1 ;
43016   std::vector< Dali::TouchPoint > *result = 0 ;
43017
43018   arg1 = (int)jarg1;
43019   {
43020     try {
43021       try {
43022         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
43023       }
43024       catch(std::out_of_range &_e) {
43025         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43026         return 0;
43027       }
43028
43029     } catch (std::out_of_range& e) {
43030       {
43031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43032       };
43033     } catch (std::exception& e) {
43034       {
43035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43036       };
43037     } catch (...) {
43038       {
43039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43040       };
43041     }
43042   }
43043   jresult = (void *)result;
43044   return jresult;
43045 }
43046
43047
43048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
43049   void * jresult ;
43050   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43051   int arg2 ;
43052   SwigValueWrapper< Dali::TouchPoint > result;
43053
43054   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43055   arg2 = (int)jarg2;
43056   {
43057     try {
43058       try {
43059         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
43060       }
43061       catch(std::out_of_range &_e) {
43062         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43063         return 0;
43064       }
43065
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::TouchPoint((const Dali::TouchPoint &)result);
43081   return jresult;
43082 }
43083
43084
43085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
43086   void * jresult ;
43087   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43088   int arg2 ;
43089   Dali::TouchPoint *result = 0 ;
43090
43091   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43092   arg2 = (int)jarg2;
43093   {
43094     try {
43095       try {
43096         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
43097       }
43098       catch(std::out_of_range &_e) {
43099         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43100         return 0;
43101       }
43102
43103     } catch (std::out_of_range& e) {
43104       {
43105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43106       };
43107     } catch (std::exception& e) {
43108       {
43109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43110       };
43111     } catch (...) {
43112       {
43113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43114       };
43115     }
43116   }
43117   jresult = (void *)result;
43118   return jresult;
43119 }
43120
43121
43122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
43123   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43124   int arg2 ;
43125   Dali::TouchPoint *arg3 = 0 ;
43126
43127   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43128   arg2 = (int)jarg2;
43129   arg3 = (Dali::TouchPoint *)jarg3;
43130   if (!arg3) {
43131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43132     return ;
43133   }
43134   {
43135     try {
43136       try {
43137         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
43138       }
43139       catch(std::out_of_range &_e) {
43140         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43141         return ;
43142       }
43143
43144     } catch (std::out_of_range& e) {
43145       {
43146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43147       };
43148     } catch (std::exception& e) {
43149       {
43150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43151       };
43152     } catch (...) {
43153       {
43154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43155       };
43156     }
43157   }
43158 }
43159
43160
43161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
43162   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43163   std::vector< Dali::TouchPoint > *arg2 = 0 ;
43164
43165   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43166   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
43167   if (!arg2) {
43168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43169     return ;
43170   }
43171   {
43172     try {
43173       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
43174     } catch (std::out_of_range& e) {
43175       {
43176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43177       };
43178     } catch (std::exception& e) {
43179       {
43180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43181       };
43182     } catch (...) {
43183       {
43184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43185       };
43186     }
43187   }
43188 }
43189
43190
43191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
43192   void * jresult ;
43193   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43194   int arg2 ;
43195   int arg3 ;
43196   std::vector< Dali::TouchPoint > *result = 0 ;
43197
43198   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43199   arg2 = (int)jarg2;
43200   arg3 = (int)jarg3;
43201   {
43202     try {
43203       try {
43204         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
43205       }
43206       catch(std::out_of_range &_e) {
43207         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43208         return 0;
43209       }
43210       catch(std::invalid_argument &_e) {
43211         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43212         return 0;
43213       }
43214
43215     } catch (std::out_of_range& e) {
43216       {
43217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43218       };
43219     } catch (std::exception& e) {
43220       {
43221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43222       };
43223     } catch (...) {
43224       {
43225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43226       };
43227     }
43228   }
43229   jresult = (void *)result;
43230   return jresult;
43231 }
43232
43233
43234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
43235   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43236   int arg2 ;
43237   Dali::TouchPoint *arg3 = 0 ;
43238
43239   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43240   arg2 = (int)jarg2;
43241   arg3 = (Dali::TouchPoint *)jarg3;
43242   if (!arg3) {
43243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43244     return ;
43245   }
43246   {
43247     try {
43248       try {
43249         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
43250       }
43251       catch(std::out_of_range &_e) {
43252         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43253         return ;
43254       }
43255
43256     } catch (std::out_of_range& e) {
43257       {
43258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43259       };
43260     } catch (std::exception& e) {
43261       {
43262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43263       };
43264     } catch (...) {
43265       {
43266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43267       };
43268     }
43269   }
43270 }
43271
43272
43273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
43274   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43275   int arg2 ;
43276   std::vector< Dali::TouchPoint > *arg3 = 0 ;
43277
43278   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43279   arg2 = (int)jarg2;
43280   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
43281   if (!arg3) {
43282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43283     return ;
43284   }
43285   {
43286     try {
43287       try {
43288         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
43289       }
43290       catch(std::out_of_range &_e) {
43291         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43292         return ;
43293       }
43294
43295     } catch (std::out_of_range& e) {
43296       {
43297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43298       };
43299     } catch (std::exception& e) {
43300       {
43301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43302       };
43303     } catch (...) {
43304       {
43305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43306       };
43307     }
43308   }
43309 }
43310
43311
43312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
43313   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43314   int arg2 ;
43315
43316   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43317   arg2 = (int)jarg2;
43318   {
43319     try {
43320       try {
43321         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
43322       }
43323       catch(std::out_of_range &_e) {
43324         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43325         return ;
43326       }
43327
43328     } catch (std::out_of_range& e) {
43329       {
43330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43331       };
43332     } catch (std::exception& e) {
43333       {
43334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43335       };
43336     } catch (...) {
43337       {
43338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43339       };
43340     }
43341   }
43342 }
43343
43344
43345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
43346   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43347   int arg2 ;
43348   int arg3 ;
43349
43350   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43351   arg2 = (int)jarg2;
43352   arg3 = (int)jarg3;
43353   {
43354     try {
43355       try {
43356         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
43357       }
43358       catch(std::out_of_range &_e) {
43359         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43360         return ;
43361       }
43362       catch(std::invalid_argument &_e) {
43363         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43364         return ;
43365       }
43366
43367     } catch (std::out_of_range& e) {
43368       {
43369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43370       };
43371     } catch (std::exception& e) {
43372       {
43373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43374       };
43375     } catch (...) {
43376       {
43377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43378       };
43379     }
43380   }
43381 }
43382
43383
43384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
43385   void * jresult ;
43386   Dali::TouchPoint *arg1 = 0 ;
43387   int arg2 ;
43388   std::vector< Dali::TouchPoint > *result = 0 ;
43389
43390   arg1 = (Dali::TouchPoint *)jarg1;
43391   if (!arg1) {
43392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43393     return 0;
43394   }
43395   arg2 = (int)jarg2;
43396   {
43397     try {
43398       try {
43399         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
43400       }
43401       catch(std::out_of_range &_e) {
43402         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43403         return 0;
43404       }
43405
43406     } catch (std::out_of_range& e) {
43407       {
43408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43409       };
43410     } catch (std::exception& e) {
43411       {
43412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43413       };
43414     } catch (...) {
43415       {
43416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43417       };
43418     }
43419   }
43420   jresult = (void *)result;
43421   return jresult;
43422 }
43423
43424
43425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
43426   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43427
43428   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43429   {
43430     try {
43431       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
43432     } catch (std::out_of_range& e) {
43433       {
43434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43435       };
43436     } catch (std::exception& e) {
43437       {
43438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43439       };
43440     } catch (...) {
43441       {
43442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43443       };
43444     }
43445   }
43446 }
43447
43448
43449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
43450   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43451   int arg2 ;
43452   int arg3 ;
43453
43454   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43455   arg2 = (int)jarg2;
43456   arg3 = (int)jarg3;
43457   {
43458     try {
43459       try {
43460         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
43461       }
43462       catch(std::out_of_range &_e) {
43463         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43464         return ;
43465       }
43466       catch(std::invalid_argument &_e) {
43467         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43468         return ;
43469       }
43470
43471     } catch (std::out_of_range& e) {
43472       {
43473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43474       };
43475     } catch (std::exception& e) {
43476       {
43477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43478       };
43479     } catch (...) {
43480       {
43481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43482       };
43483     }
43484   }
43485 }
43486
43487
43488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
43489   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43490   int arg2 ;
43491   std::vector< Dali::TouchPoint > *arg3 = 0 ;
43492
43493   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43494   arg2 = (int)jarg2;
43495   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
43496   if (!arg3) {
43497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43498     return ;
43499   }
43500   {
43501     try {
43502       try {
43503         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
43504       }
43505       catch(std::out_of_range &_e) {
43506         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43507         return ;
43508       }
43509
43510     } catch (std::out_of_range& e) {
43511       {
43512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43513       };
43514     } catch (std::exception& e) {
43515       {
43516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43517       };
43518     } catch (...) {
43519       {
43520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43521       };
43522     }
43523   }
43524 }
43525
43526
43527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
43528   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43529
43530   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43531   {
43532     try {
43533       delete arg1;
43534     } catch (std::out_of_range& e) {
43535       {
43536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43537       };
43538     } catch (std::exception& e) {
43539       {
43540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43541       };
43542     } catch (...) {
43543       {
43544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43545       };
43546     }
43547   }
43548 }
43549
43550
43551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
43552   void * jresult ;
43553   Dali::Rect< int > *result = 0 ;
43554
43555   {
43556     try {
43557       result = (Dali::Rect< int > *)new Dali::Rect< int >();
43558     } catch (std::out_of_range& e) {
43559       {
43560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43561       };
43562     } catch (std::exception& e) {
43563       {
43564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43565       };
43566     } catch (...) {
43567       {
43568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43569       };
43570     }
43571   }
43572   jresult = (void *)result;
43573   return jresult;
43574 }
43575
43576
43577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
43578   void * jresult ;
43579   int arg1 ;
43580   int arg2 ;
43581   int arg3 ;
43582   int arg4 ;
43583   Dali::Rect< int > *result = 0 ;
43584
43585   arg1 = (int)jarg1;
43586   arg2 = (int)jarg2;
43587   arg3 = (int)jarg3;
43588   arg4 = (int)jarg4;
43589   {
43590     try {
43591       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
43592     } catch (std::out_of_range& e) {
43593       {
43594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43595       };
43596     } catch (std::exception& e) {
43597       {
43598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43599       };
43600     } catch (...) {
43601       {
43602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43603       };
43604     }
43605   }
43606   jresult = (void *)result;
43607   return jresult;
43608 }
43609
43610
43611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
43612   void * jresult ;
43613   Dali::Rect< int > *arg1 = 0 ;
43614   Dali::Rect< int > *result = 0 ;
43615
43616   arg1 = (Dali::Rect< int > *)jarg1;
43617   if (!arg1) {
43618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43619     return 0;
43620   }
43621   {
43622     try {
43623       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
43624     } catch (std::out_of_range& e) {
43625       {
43626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43627       };
43628     } catch (std::exception& e) {
43629       {
43630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43631       };
43632     } catch (...) {
43633       {
43634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43635       };
43636     }
43637   }
43638   jresult = (void *)result;
43639   return jresult;
43640 }
43641
43642
43643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
43644   void * jresult ;
43645   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43646   Dali::Rect< int > *arg2 = 0 ;
43647   Dali::Rect< int > *result = 0 ;
43648
43649   arg1 = (Dali::Rect< int > *)jarg1;
43650   arg2 = (Dali::Rect< int > *)jarg2;
43651   if (!arg2) {
43652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43653     return 0;
43654   }
43655   {
43656     try {
43657       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
43658     } catch (std::out_of_range& e) {
43659       {
43660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43661       };
43662     } catch (std::exception& e) {
43663       {
43664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43665       };
43666     } catch (...) {
43667       {
43668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43669       };
43670     }
43671   }
43672   jresult = (void *)result;
43673   return jresult;
43674 }
43675
43676
43677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
43678   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43679   int arg2 ;
43680   int arg3 ;
43681   int arg4 ;
43682   int arg5 ;
43683
43684   arg1 = (Dali::Rect< int > *)jarg1;
43685   arg2 = (int)jarg2;
43686   arg3 = (int)jarg3;
43687   arg4 = (int)jarg4;
43688   arg5 = (int)jarg5;
43689   {
43690     try {
43691       (arg1)->Set(arg2,arg3,arg4,arg5);
43692     } catch (std::out_of_range& e) {
43693       {
43694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43695       };
43696     } catch (std::exception& e) {
43697       {
43698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43699       };
43700     } catch (...) {
43701       {
43702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43703       };
43704     }
43705   }
43706 }
43707
43708
43709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
43710   unsigned int jresult ;
43711   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43712   bool result;
43713
43714   arg1 = (Dali::Rect< int > *)jarg1;
43715   {
43716     try {
43717       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
43718     } catch (std::out_of_range& e) {
43719       {
43720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43721       };
43722     } catch (std::exception& e) {
43723       {
43724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43725       };
43726     } catch (...) {
43727       {
43728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43729       };
43730     }
43731   }
43732   jresult = result;
43733   return jresult;
43734 }
43735
43736
43737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
43738   int jresult ;
43739   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43740   int result;
43741
43742   arg1 = (Dali::Rect< int > *)jarg1;
43743   {
43744     try {
43745       result = (int)((Dali::Rect< int > const *)arg1)->Left();
43746     } catch (std::out_of_range& e) {
43747       {
43748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43749       };
43750     } catch (std::exception& e) {
43751       {
43752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43753       };
43754     } catch (...) {
43755       {
43756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43757       };
43758     }
43759   }
43760   jresult = result;
43761   return jresult;
43762 }
43763
43764
43765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
43766   int jresult ;
43767   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43768   int result;
43769
43770   arg1 = (Dali::Rect< int > *)jarg1;
43771   {
43772     try {
43773       result = (int)((Dali::Rect< int > const *)arg1)->Right();
43774     } catch (std::out_of_range& e) {
43775       {
43776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43777       };
43778     } catch (std::exception& e) {
43779       {
43780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43781       };
43782     } catch (...) {
43783       {
43784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43785       };
43786     }
43787   }
43788   jresult = result;
43789   return jresult;
43790 }
43791
43792
43793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
43794   int jresult ;
43795   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43796   int result;
43797
43798   arg1 = (Dali::Rect< int > *)jarg1;
43799   {
43800     try {
43801       result = (int)((Dali::Rect< int > const *)arg1)->Top();
43802     } catch (std::out_of_range& e) {
43803       {
43804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43805       };
43806     } catch (std::exception& e) {
43807       {
43808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43809       };
43810     } catch (...) {
43811       {
43812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43813       };
43814     }
43815   }
43816   jresult = result;
43817   return jresult;
43818 }
43819
43820
43821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
43822   int jresult ;
43823   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43824   int result;
43825
43826   arg1 = (Dali::Rect< int > *)jarg1;
43827   {
43828     try {
43829       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
43830     } catch (std::out_of_range& e) {
43831       {
43832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43833       };
43834     } catch (std::exception& e) {
43835       {
43836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43837       };
43838     } catch (...) {
43839       {
43840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43841       };
43842     }
43843   }
43844   jresult = result;
43845   return jresult;
43846 }
43847
43848
43849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
43850   int jresult ;
43851   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43852   int result;
43853
43854   arg1 = (Dali::Rect< int > *)jarg1;
43855   {
43856     try {
43857       result = (int)((Dali::Rect< int > const *)arg1)->Area();
43858     } catch (std::out_of_range& e) {
43859       {
43860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43861       };
43862     } catch (std::exception& e) {
43863       {
43864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43865       };
43866     } catch (...) {
43867       {
43868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43869       };
43870     }
43871   }
43872   jresult = result;
43873   return jresult;
43874 }
43875
43876
43877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
43878   unsigned int jresult ;
43879   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43880   Dali::Rect< int > *arg2 = 0 ;
43881   bool result;
43882
43883   arg1 = (Dali::Rect< int > *)jarg1;
43884   arg2 = (Dali::Rect< int > *)jarg2;
43885   if (!arg2) {
43886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43887     return 0;
43888   }
43889   {
43890     try {
43891       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
43892     } catch (std::out_of_range& e) {
43893       {
43894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43895       };
43896     } catch (std::exception& e) {
43897       {
43898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43899       };
43900     } catch (...) {
43901       {
43902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43903       };
43904     }
43905   }
43906   jresult = result;
43907   return jresult;
43908 }
43909
43910
43911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
43912   unsigned int jresult ;
43913   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43914   Dali::Rect< int > *arg2 = 0 ;
43915   bool result;
43916
43917   arg1 = (Dali::Rect< int > *)jarg1;
43918   arg2 = (Dali::Rect< int > *)jarg2;
43919   if (!arg2) {
43920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43921     return 0;
43922   }
43923   {
43924     try {
43925       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
43926     } catch (std::out_of_range& e) {
43927       {
43928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43929       };
43930     } catch (std::exception& e) {
43931       {
43932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43933       };
43934     } catch (...) {
43935       {
43936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43937       };
43938     }
43939   }
43940   jresult = result;
43941   return jresult;
43942 }
43943
43944
43945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
43946   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43947   int arg2 ;
43948
43949   arg1 = (Dali::Rect< int > *)jarg1;
43950   arg2 = (int)jarg2;
43951   if (arg1) (arg1)->x = arg2;
43952 }
43953
43954
43955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
43956   int jresult ;
43957   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43958   int result;
43959
43960   arg1 = (Dali::Rect< int > *)jarg1;
43961   result = (int) ((arg1)->x);
43962   jresult = result;
43963   return jresult;
43964 }
43965
43966
43967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
43968   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43969   int arg2 ;
43970
43971   arg1 = (Dali::Rect< int > *)jarg1;
43972   arg2 = (int)jarg2;
43973   if (arg1) (arg1)->left = arg2;
43974 }
43975
43976
43977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
43978   int jresult ;
43979   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43980   int result;
43981
43982   arg1 = (Dali::Rect< int > *)jarg1;
43983   result = (int) ((arg1)->left);
43984   jresult = result;
43985   return jresult;
43986 }
43987
43988
43989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
43990   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43991   int arg2 ;
43992
43993   arg1 = (Dali::Rect< int > *)jarg1;
43994   arg2 = (int)jarg2;
43995   if (arg1) (arg1)->y = arg2;
43996 }
43997
43998
43999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
44000   int jresult ;
44001   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44002   int result;
44003
44004   arg1 = (Dali::Rect< int > *)jarg1;
44005   result = (int) ((arg1)->y);
44006   jresult = result;
44007   return jresult;
44008 }
44009
44010
44011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
44012   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44013   int arg2 ;
44014
44015   arg1 = (Dali::Rect< int > *)jarg1;
44016   arg2 = (int)jarg2;
44017   if (arg1) (arg1)->right = arg2;
44018 }
44019
44020
44021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
44022   int jresult ;
44023   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44024   int result;
44025
44026   arg1 = (Dali::Rect< int > *)jarg1;
44027   result = (int) ((arg1)->right);
44028   jresult = result;
44029   return jresult;
44030 }
44031
44032
44033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
44034   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44035   int arg2 ;
44036
44037   arg1 = (Dali::Rect< int > *)jarg1;
44038   arg2 = (int)jarg2;
44039   if (arg1) (arg1)->width = arg2;
44040 }
44041
44042
44043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
44044   int jresult ;
44045   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44046   int result;
44047
44048   arg1 = (Dali::Rect< int > *)jarg1;
44049   result = (int) ((arg1)->width);
44050   jresult = result;
44051   return jresult;
44052 }
44053
44054
44055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
44056   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44057   int arg2 ;
44058
44059   arg1 = (Dali::Rect< int > *)jarg1;
44060   arg2 = (int)jarg2;
44061   if (arg1) (arg1)->bottom = arg2;
44062 }
44063
44064
44065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
44066   int jresult ;
44067   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44068   int result;
44069
44070   arg1 = (Dali::Rect< int > *)jarg1;
44071   result = (int) ((arg1)->bottom);
44072   jresult = result;
44073   return jresult;
44074 }
44075
44076
44077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
44078   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44079   int arg2 ;
44080
44081   arg1 = (Dali::Rect< int > *)jarg1;
44082   arg2 = (int)jarg2;
44083   if (arg1) (arg1)->height = arg2;
44084 }
44085
44086
44087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
44088   int jresult ;
44089   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44090   int result;
44091
44092   arg1 = (Dali::Rect< int > *)jarg1;
44093   result = (int) ((arg1)->height);
44094   jresult = result;
44095   return jresult;
44096 }
44097
44098
44099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
44100   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44101   int arg2 ;
44102
44103   arg1 = (Dali::Rect< int > *)jarg1;
44104   arg2 = (int)jarg2;
44105   if (arg1) (arg1)->top = arg2;
44106 }
44107
44108
44109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
44110   int jresult ;
44111   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44112   int result;
44113
44114   arg1 = (Dali::Rect< int > *)jarg1;
44115   result = (int) ((arg1)->top);
44116   jresult = result;
44117   return jresult;
44118 }
44119
44120
44121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
44122   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44123
44124   arg1 = (Dali::Rect< int > *)jarg1;
44125   {
44126     try {
44127       delete arg1;
44128     } catch (std::out_of_range& e) {
44129       {
44130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44131       };
44132     } catch (std::exception& e) {
44133       {
44134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44135       };
44136     } catch (...) {
44137       {
44138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44139       };
44140     }
44141   }
44142 }
44143
44144
44145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
44146   void * jresult ;
44147   Dali::Rect< float > *result = 0 ;
44148
44149   {
44150     try {
44151       result = (Dali::Rect< float > *)new Dali::Rect< float >();
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 = (void *)result;
44167   return jresult;
44168 }
44169
44170
44171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
44172   void * jresult ;
44173   float arg1 ;
44174   float arg2 ;
44175   float arg3 ;
44176   float arg4 ;
44177   Dali::Rect< float > *result = 0 ;
44178
44179   arg1 = (float)jarg1;
44180   arg2 = (float)jarg2;
44181   arg3 = (float)jarg4;
44182   arg4 = (float)jarg3;
44183   {
44184     try {
44185       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
44186     } catch (std::out_of_range& e) {
44187       {
44188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44189       };
44190     } catch (std::exception& e) {
44191       {
44192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44193       };
44194     } catch (...) {
44195       {
44196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44197       };
44198     }
44199   }
44200   jresult = (void *)result;
44201   return jresult;
44202 }
44203
44204
44205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
44206   void * jresult ;
44207   Dali::Rect< float > *arg1 = 0 ;
44208   Dali::Rect< float > *result = 0 ;
44209
44210   arg1 = (Dali::Rect< float > *)jarg1;
44211   if (!arg1) {
44212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
44213     return 0;
44214   }
44215   {
44216     try {
44217       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
44218     } catch (std::out_of_range& e) {
44219       {
44220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44221       };
44222     } catch (std::exception& e) {
44223       {
44224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44225       };
44226     } catch (...) {
44227       {
44228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44229       };
44230     }
44231   }
44232   jresult = (void *)result;
44233   return jresult;
44234 }
44235
44236
44237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
44238   void * jresult ;
44239   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44240   Dali::Rect< float > *arg2 = 0 ;
44241   Dali::Rect< float > *result = 0 ;
44242
44243   arg1 = (Dali::Rect< float > *)jarg1;
44244   arg2 = (Dali::Rect< float > *)jarg2;
44245   if (!arg2) {
44246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
44247     return 0;
44248   }
44249   {
44250     try {
44251       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
44252     } catch (std::out_of_range& e) {
44253       {
44254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44255       };
44256     } catch (std::exception& e) {
44257       {
44258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44259       };
44260     } catch (...) {
44261       {
44262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44263       };
44264     }
44265   }
44266   jresult = (void *)result;
44267   return jresult;
44268 }
44269
44270
44271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
44272   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44273   float arg2 ;
44274   float arg3 ;
44275   float arg4 ;
44276   float arg5 ;
44277
44278   arg1 = (Dali::Rect< float > *)jarg1;
44279   arg2 = (float)jarg2;
44280   arg3 = (float)jarg3;
44281   arg4 = (float)jarg5;
44282   arg5 = (float)jarg4;
44283   {
44284     try {
44285       (arg1)->Set(arg2,arg3,arg4,arg5);
44286     } catch (std::out_of_range& e) {
44287       {
44288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44289       };
44290     } catch (std::exception& e) {
44291       {
44292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44293       };
44294     } catch (...) {
44295       {
44296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44297       };
44298     }
44299   }
44300 }
44301
44302
44303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
44304   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44305   float arg2 ;
44306
44307   arg1 = (Dali::Rect< float > *)jarg1;
44308   arg2 = (float)jarg2;
44309   if (arg1) (arg1)->left = arg2;
44310 }
44311
44312
44313 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
44314   float jresult ;
44315   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44316   float result;
44317
44318   arg1 = (Dali::Rect< float > *)jarg1;
44319   result = (float) ((arg1)->left);
44320   jresult = result;
44321   return jresult;
44322 }
44323
44324
44325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
44326   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44327   float arg2 ;
44328
44329   arg1 = (Dali::Rect< float > *)jarg1;
44330   arg2 = (float)jarg2;
44331   if (arg1) (arg1)->left = arg2;
44332 }
44333
44334
44335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
44336   float jresult ;
44337   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44338   float result;
44339
44340   arg1 = (Dali::Rect< float > *)jarg1;
44341   result = (float) ((arg1)->left);
44342   jresult = result;
44343   return jresult;
44344 }
44345
44346
44347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
44348   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44349   float arg2 ;
44350
44351   arg1 = (Dali::Rect< float > *)jarg1;
44352   arg2 = (float)jarg2;
44353   if (arg1) (arg1)->right = arg2;
44354 }
44355
44356
44357 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
44358   float jresult ;
44359   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44360   float result;
44361
44362   arg1 = (Dali::Rect< float > *)jarg1;
44363   result = (float) ((arg1)->right);
44364   jresult = result;
44365   return jresult;
44366 }
44367
44368
44369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
44370   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44371   float arg2 ;
44372
44373   arg1 = (Dali::Rect< float > *)jarg1;
44374   arg2 = (float)jarg2;
44375   if (arg1) (arg1)->right = arg2;
44376 }
44377
44378
44379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
44380   float jresult ;
44381   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44382   float result;
44383
44384   arg1 = (Dali::Rect< float > *)jarg1;
44385   result = (float) ((arg1)->right);
44386   jresult = result;
44387   return jresult;
44388 }
44389
44390
44391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
44392   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44393   float arg2 ;
44394
44395   arg1 = (Dali::Rect< float > *)jarg1;
44396   arg2 = (float)jarg2;
44397   if (arg1) (arg1)->bottom = arg2;
44398 }
44399
44400
44401 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
44402   float jresult ;
44403   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44404   float result;
44405
44406   arg1 = (Dali::Rect< float > *)jarg1;
44407   result = (float) ((arg1)->bottom);
44408   jresult = result;
44409   return jresult;
44410 }
44411
44412
44413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
44414   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44415   float arg2 ;
44416
44417   arg1 = (Dali::Rect< float > *)jarg1;
44418   arg2 = (float)jarg2;
44419   if (arg1) (arg1)->top = arg2;
44420 }
44421
44422
44423 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
44424   float jresult ;
44425   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44426   float result;
44427
44428   arg1 = (Dali::Rect< float > *)jarg1;
44429   result = (float) ((arg1)->top);
44430   jresult = result;
44431   return jresult;
44432 }
44433
44434
44435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
44436   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44437
44438   arg1 = (Dali::Rect< float > *)jarg1;
44439   {
44440     try {
44441       delete arg1;
44442     } catch (std::out_of_range& e) {
44443       {
44444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44445       };
44446     } catch (std::exception& e) {
44447       {
44448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44449       };
44450     } catch (...) {
44451       {
44452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44453       };
44454     }
44455   }
44456 }
44457
44458
44459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
44460   int jresult ;
44461   int result;
44462
44463   result = (int)Dali::Vector< int >::BaseType;
44464   jresult = (int)result;
44465   return jresult;
44466 }
44467
44468
44469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
44470   void * jresult ;
44471   Dali::Vector< int > *result = 0 ;
44472
44473   {
44474     try {
44475       result = (Dali::Vector< int > *)new Dali::Vector< int >();
44476     } catch (std::out_of_range& e) {
44477       {
44478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44479       };
44480     } catch (std::exception& e) {
44481       {
44482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44483       };
44484     } catch (...) {
44485       {
44486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44487       };
44488     }
44489   }
44490   jresult = (void *)result;
44491   return jresult;
44492 }
44493
44494
44495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
44496   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44497
44498   arg1 = (Dali::Vector< int > *)jarg1;
44499   {
44500     try {
44501       delete arg1;
44502     } catch (std::out_of_range& e) {
44503       {
44504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44505       };
44506     } catch (std::exception& e) {
44507       {
44508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44509       };
44510     } catch (...) {
44511       {
44512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44513       };
44514     }
44515   }
44516 }
44517
44518
44519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
44520   void * jresult ;
44521   Dali::Vector< int > *arg1 = 0 ;
44522   Dali::Vector< int > *result = 0 ;
44523
44524   arg1 = (Dali::Vector< int > *)jarg1;
44525   if (!arg1) {
44526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
44527     return 0;
44528   }
44529   {
44530     try {
44531       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
44532     } catch (std::out_of_range& e) {
44533       {
44534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44535       };
44536     } catch (std::exception& e) {
44537       {
44538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44539       };
44540     } catch (...) {
44541       {
44542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44543       };
44544     }
44545   }
44546   jresult = (void *)result;
44547   return jresult;
44548 }
44549
44550
44551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
44552   void * jresult ;
44553   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44554   Dali::Vector< int > *arg2 = 0 ;
44555   Dali::Vector< int > *result = 0 ;
44556
44557   arg1 = (Dali::Vector< int > *)jarg1;
44558   arg2 = (Dali::Vector< int > *)jarg2;
44559   if (!arg2) {
44560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
44561     return 0;
44562   }
44563   {
44564     try {
44565       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
44566     } catch (std::out_of_range& e) {
44567       {
44568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44569       };
44570     } catch (std::exception& e) {
44571       {
44572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44573       };
44574     } catch (...) {
44575       {
44576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44577       };
44578     }
44579   }
44580   jresult = (void *)result;
44581   return jresult;
44582 }
44583
44584
44585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
44586   void * jresult ;
44587   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44588   Dali::Vector< int >::Iterator result;
44589
44590   arg1 = (Dali::Vector< int > *)jarg1;
44591   {
44592     try {
44593       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
44594     } catch (std::out_of_range& e) {
44595       {
44596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44597       };
44598     } catch (std::exception& e) {
44599       {
44600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44601       };
44602     } catch (...) {
44603       {
44604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44605       };
44606     }
44607   }
44608   jresult = (void *)result;
44609   return jresult;
44610 }
44611
44612
44613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
44614   void * jresult ;
44615   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44616   Dali::Vector< int >::Iterator result;
44617
44618   arg1 = (Dali::Vector< int > *)jarg1;
44619   {
44620     try {
44621       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
44622     } catch (std::out_of_range& e) {
44623       {
44624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44625       };
44626     } catch (std::exception& e) {
44627       {
44628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44629       };
44630     } catch (...) {
44631       {
44632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44633       };
44634     }
44635   }
44636   jresult = (void *)result;
44637   return jresult;
44638 }
44639
44640
44641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
44642   void * jresult ;
44643   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44644   Dali::Vector< int >::SizeType arg2 ;
44645   Dali::Vector< int >::ItemType *result = 0 ;
44646
44647   arg1 = (Dali::Vector< int > *)jarg1;
44648   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44649   {
44650     try {
44651       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
44652     } catch (std::out_of_range& e) {
44653       {
44654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44655       };
44656     } catch (std::exception& e) {
44657       {
44658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44659       };
44660     } catch (...) {
44661       {
44662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44663       };
44664     }
44665   }
44666   jresult = (void *)result;
44667   return jresult;
44668 }
44669
44670
44671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
44672   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44673   Dali::Vector< int >::ItemType *arg2 = 0 ;
44674   Dali::Vector< int >::ItemType temp2 ;
44675
44676   arg1 = (Dali::Vector< int > *)jarg1;
44677   temp2 = (Dali::Vector< int >::ItemType)jarg2;
44678   arg2 = &temp2;
44679   {
44680     try {
44681       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
44682     } catch (std::out_of_range& e) {
44683       {
44684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44685       };
44686     } catch (std::exception& e) {
44687       {
44688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44689       };
44690     } catch (...) {
44691       {
44692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44693       };
44694     }
44695   }
44696 }
44697
44698
44699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
44700   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44701   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44702   Dali::Vector< int >::ItemType *arg3 = 0 ;
44703   Dali::Vector< int >::ItemType temp3 ;
44704
44705   arg1 = (Dali::Vector< int > *)jarg1;
44706   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44707   temp3 = (Dali::Vector< int >::ItemType)jarg3;
44708   arg3 = &temp3;
44709   {
44710     try {
44711       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
44712     } catch (std::out_of_range& e) {
44713       {
44714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44715       };
44716     } catch (std::exception& e) {
44717       {
44718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44719       };
44720     } catch (...) {
44721       {
44722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44723       };
44724     }
44725   }
44726 }
44727
44728
44729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44730   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44731   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44732   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
44733   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
44734
44735   arg1 = (Dali::Vector< int > *)jarg1;
44736   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44737   arg3 = (Dali::Vector< int >::Iterator)jarg3;
44738   arg4 = (Dali::Vector< int >::Iterator)jarg4;
44739   {
44740     try {
44741       (arg1)->Insert(arg2,arg3,arg4);
44742     } catch (std::out_of_range& e) {
44743       {
44744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44745       };
44746     } catch (std::exception& e) {
44747       {
44748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44749       };
44750     } catch (...) {
44751       {
44752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44753       };
44754     }
44755   }
44756 }
44757
44758
44759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
44760   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44761   Dali::Vector< int >::SizeType arg2 ;
44762
44763   arg1 = (Dali::Vector< int > *)jarg1;
44764   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44765   {
44766     try {
44767       (arg1)->Reserve(arg2);
44768     } catch (std::out_of_range& e) {
44769       {
44770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44771       };
44772     } catch (std::exception& e) {
44773       {
44774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44775       };
44776     } catch (...) {
44777       {
44778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44779       };
44780     }
44781   }
44782 }
44783
44784
44785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
44786   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44787   Dali::Vector< int >::SizeType arg2 ;
44788
44789   arg1 = (Dali::Vector< int > *)jarg1;
44790   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44791   {
44792     try {
44793       (arg1)->Resize(arg2);
44794     } catch (std::out_of_range& e) {
44795       {
44796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44797       };
44798     } catch (std::exception& e) {
44799       {
44800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44801       };
44802     } catch (...) {
44803       {
44804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44805       };
44806     }
44807   }
44808 }
44809
44810
44811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
44812   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44813   Dali::Vector< int >::SizeType arg2 ;
44814   Dali::Vector< int >::ItemType *arg3 = 0 ;
44815   Dali::Vector< int >::ItemType temp3 ;
44816
44817   arg1 = (Dali::Vector< int > *)jarg1;
44818   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44819   temp3 = (Dali::Vector< int >::ItemType)jarg3;
44820   arg3 = &temp3;
44821   {
44822     try {
44823       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
44824     } catch (std::out_of_range& e) {
44825       {
44826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44827       };
44828     } catch (std::exception& e) {
44829       {
44830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44831       };
44832     } catch (...) {
44833       {
44834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44835       };
44836     }
44837   }
44838 }
44839
44840
44841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
44842   void * jresult ;
44843   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44844   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44845   Dali::Vector< int >::Iterator result;
44846
44847   arg1 = (Dali::Vector< int > *)jarg1;
44848   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44849   {
44850     try {
44851       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
44852     } catch (std::out_of_range& e) {
44853       {
44854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44855       };
44856     } catch (std::exception& e) {
44857       {
44858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44859       };
44860     } catch (...) {
44861       {
44862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44863       };
44864     }
44865   }
44866   jresult = (void *)result;
44867   return jresult;
44868 }
44869
44870
44871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
44872   void * jresult ;
44873   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44874   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44875   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
44876   Dali::Vector< int >::Iterator result;
44877
44878   arg1 = (Dali::Vector< int > *)jarg1;
44879   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44880   arg3 = (Dali::Vector< int >::Iterator)jarg3;
44881   {
44882     try {
44883       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
44884     } catch (std::out_of_range& e) {
44885       {
44886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44887       };
44888     } catch (std::exception& e) {
44889       {
44890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44891       };
44892     } catch (...) {
44893       {
44894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44895       };
44896     }
44897   }
44898   jresult = (void *)result;
44899   return jresult;
44900 }
44901
44902
44903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
44904   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44905   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44906
44907   arg1 = (Dali::Vector< int > *)jarg1;
44908   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44909   {
44910     try {
44911       (arg1)->Remove(arg2);
44912     } catch (std::out_of_range& e) {
44913       {
44914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44915       };
44916     } catch (std::exception& e) {
44917       {
44918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44919       };
44920     } catch (...) {
44921       {
44922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44923       };
44924     }
44925   }
44926 }
44927
44928
44929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
44930   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44931   Dali::Vector< int > *arg2 = 0 ;
44932
44933   arg1 = (Dali::Vector< int > *)jarg1;
44934   arg2 = (Dali::Vector< int > *)jarg2;
44935   if (!arg2) {
44936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
44937     return ;
44938   }
44939   {
44940     try {
44941       (arg1)->Swap(*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_VectorInteger_Clear(void * jarg1) {
44960   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44961
44962   arg1 = (Dali::Vector< int > *)jarg1;
44963   {
44964     try {
44965       (arg1)->Clear();
44966     } catch (std::out_of_range& e) {
44967       {
44968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44969       };
44970     } catch (std::exception& e) {
44971       {
44972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44973       };
44974     } catch (...) {
44975       {
44976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44977       };
44978     }
44979   }
44980 }
44981
44982
44983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
44984   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44985
44986   arg1 = (Dali::Vector< int > *)jarg1;
44987   {
44988     try {
44989       (arg1)->Release();
44990     } catch (std::out_of_range& e) {
44991       {
44992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44993       };
44994     } catch (std::exception& e) {
44995       {
44996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44997       };
44998     } catch (...) {
44999       {
45000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45001       };
45002     }
45003   }
45004 }
45005
45006
45007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
45008   int jresult ;
45009   int result;
45010
45011   result = (int)Dali::Vector< float >::BaseType;
45012   jresult = (int)result;
45013   return jresult;
45014 }
45015
45016
45017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
45018   void * jresult ;
45019   Dali::Vector< float > *result = 0 ;
45020
45021   {
45022     try {
45023       result = (Dali::Vector< float > *)new Dali::Vector< float >();
45024     } catch (std::out_of_range& e) {
45025       {
45026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45027       };
45028     } catch (std::exception& e) {
45029       {
45030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45031       };
45032     } catch (...) {
45033       {
45034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45035       };
45036     }
45037   }
45038   jresult = (void *)result;
45039   return jresult;
45040 }
45041
45042
45043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
45044   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45045
45046   arg1 = (Dali::Vector< float > *)jarg1;
45047   {
45048     try {
45049       delete arg1;
45050     } catch (std::out_of_range& e) {
45051       {
45052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45053       };
45054     } catch (std::exception& e) {
45055       {
45056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45057       };
45058     } catch (...) {
45059       {
45060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45061       };
45062     }
45063   }
45064 }
45065
45066
45067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
45068   void * jresult ;
45069   Dali::Vector< float > *arg1 = 0 ;
45070   Dali::Vector< float > *result = 0 ;
45071
45072   arg1 = (Dali::Vector< float > *)jarg1;
45073   if (!arg1) {
45074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
45075     return 0;
45076   }
45077   {
45078     try {
45079       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
45080     } catch (std::out_of_range& e) {
45081       {
45082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45083       };
45084     } catch (std::exception& e) {
45085       {
45086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45087       };
45088     } catch (...) {
45089       {
45090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45091       };
45092     }
45093   }
45094   jresult = (void *)result;
45095   return jresult;
45096 }
45097
45098
45099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
45100   void * jresult ;
45101   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45102   Dali::Vector< float > *arg2 = 0 ;
45103   Dali::Vector< float > *result = 0 ;
45104
45105   arg1 = (Dali::Vector< float > *)jarg1;
45106   arg2 = (Dali::Vector< float > *)jarg2;
45107   if (!arg2) {
45108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
45109     return 0;
45110   }
45111   {
45112     try {
45113       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
45114     } catch (std::out_of_range& e) {
45115       {
45116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45117       };
45118     } catch (std::exception& e) {
45119       {
45120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45121       };
45122     } catch (...) {
45123       {
45124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45125       };
45126     }
45127   }
45128   jresult = (void *)result;
45129   return jresult;
45130 }
45131
45132
45133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
45134   void * jresult ;
45135   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45136   Dali::Vector< float >::Iterator result;
45137
45138   arg1 = (Dali::Vector< float > *)jarg1;
45139   {
45140     try {
45141       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
45142     } catch (std::out_of_range& e) {
45143       {
45144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45145       };
45146     } catch (std::exception& e) {
45147       {
45148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45149       };
45150     } catch (...) {
45151       {
45152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45153       };
45154     }
45155   }
45156   jresult = (void *)result;
45157   return jresult;
45158 }
45159
45160
45161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
45162   void * jresult ;
45163   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45164   Dali::Vector< float >::Iterator result;
45165
45166   arg1 = (Dali::Vector< float > *)jarg1;
45167   {
45168     try {
45169       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
45170     } catch (std::out_of_range& e) {
45171       {
45172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45173       };
45174     } catch (std::exception& e) {
45175       {
45176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45177       };
45178     } catch (...) {
45179       {
45180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45181       };
45182     }
45183   }
45184   jresult = (void *)result;
45185   return jresult;
45186 }
45187
45188
45189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
45190   void * jresult ;
45191   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45192   Dali::Vector< float >::SizeType arg2 ;
45193   Dali::Vector< float >::ItemType *result = 0 ;
45194
45195   arg1 = (Dali::Vector< float > *)jarg1;
45196   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45197   {
45198     try {
45199       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
45200     } catch (std::out_of_range& e) {
45201       {
45202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45203       };
45204     } catch (std::exception& e) {
45205       {
45206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45207       };
45208     } catch (...) {
45209       {
45210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45211       };
45212     }
45213   }
45214   jresult = (void *)result;
45215   return jresult;
45216 }
45217
45218
45219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
45220   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45221   Dali::Vector< float >::ItemType *arg2 = 0 ;
45222   Dali::Vector< float >::ItemType temp2 ;
45223
45224   arg1 = (Dali::Vector< float > *)jarg1;
45225   temp2 = (Dali::Vector< float >::ItemType)jarg2;
45226   arg2 = &temp2;
45227   {
45228     try {
45229       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
45230     } catch (std::out_of_range& e) {
45231       {
45232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45233       };
45234     } catch (std::exception& e) {
45235       {
45236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45237       };
45238     } catch (...) {
45239       {
45240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45241       };
45242     }
45243   }
45244 }
45245
45246
45247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
45248   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45249   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45250   Dali::Vector< float >::ItemType *arg3 = 0 ;
45251   Dali::Vector< float >::ItemType temp3 ;
45252
45253   arg1 = (Dali::Vector< float > *)jarg1;
45254   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45255   temp3 = (Dali::Vector< float >::ItemType)jarg3;
45256   arg3 = &temp3;
45257   {
45258     try {
45259       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
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_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
45278   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45279   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45280   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
45281   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
45282
45283   arg1 = (Dali::Vector< float > *)jarg1;
45284   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45285   arg3 = (Dali::Vector< float >::Iterator)jarg3;
45286   arg4 = (Dali::Vector< float >::Iterator)jarg4;
45287   {
45288     try {
45289       (arg1)->Insert(arg2,arg3,arg4);
45290     } catch (std::out_of_range& e) {
45291       {
45292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45293       };
45294     } catch (std::exception& e) {
45295       {
45296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45297       };
45298     } catch (...) {
45299       {
45300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45301       };
45302     }
45303   }
45304 }
45305
45306
45307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
45308   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45309   Dali::Vector< float >::SizeType arg2 ;
45310
45311   arg1 = (Dali::Vector< float > *)jarg1;
45312   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45313   {
45314     try {
45315       (arg1)->Reserve(arg2);
45316     } catch (std::out_of_range& e) {
45317       {
45318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45319       };
45320     } catch (std::exception& e) {
45321       {
45322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45323       };
45324     } catch (...) {
45325       {
45326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45327       };
45328     }
45329   }
45330 }
45331
45332
45333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
45334   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45335   Dali::Vector< float >::SizeType arg2 ;
45336
45337   arg1 = (Dali::Vector< float > *)jarg1;
45338   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45339   {
45340     try {
45341       (arg1)->Resize(arg2);
45342     } catch (std::out_of_range& e) {
45343       {
45344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45345       };
45346     } catch (std::exception& e) {
45347       {
45348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45349       };
45350     } catch (...) {
45351       {
45352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45353       };
45354     }
45355   }
45356 }
45357
45358
45359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
45360   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45361   Dali::Vector< float >::SizeType arg2 ;
45362   Dali::Vector< float >::ItemType *arg3 = 0 ;
45363   Dali::Vector< float >::ItemType temp3 ;
45364
45365   arg1 = (Dali::Vector< float > *)jarg1;
45366   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45367   temp3 = (Dali::Vector< float >::ItemType)jarg3;
45368   arg3 = &temp3;
45369   {
45370     try {
45371       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
45372     } catch (std::out_of_range& e) {
45373       {
45374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45375       };
45376     } catch (std::exception& e) {
45377       {
45378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45379       };
45380     } catch (...) {
45381       {
45382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45383       };
45384     }
45385   }
45386 }
45387
45388
45389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
45390   void * jresult ;
45391   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45392   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45393   Dali::Vector< float >::Iterator result;
45394
45395   arg1 = (Dali::Vector< float > *)jarg1;
45396   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45397   {
45398     try {
45399       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
45400     } catch (std::out_of_range& e) {
45401       {
45402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45403       };
45404     } catch (std::exception& e) {
45405       {
45406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45407       };
45408     } catch (...) {
45409       {
45410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45411       };
45412     }
45413   }
45414   jresult = (void *)result;
45415   return jresult;
45416 }
45417
45418
45419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
45420   void * jresult ;
45421   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45422   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45423   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
45424   Dali::Vector< float >::Iterator result;
45425
45426   arg1 = (Dali::Vector< float > *)jarg1;
45427   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45428   arg3 = (Dali::Vector< float >::Iterator)jarg3;
45429   {
45430     try {
45431       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
45432     } catch (std::out_of_range& e) {
45433       {
45434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45435       };
45436     } catch (std::exception& e) {
45437       {
45438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45439       };
45440     } catch (...) {
45441       {
45442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45443       };
45444     }
45445   }
45446   jresult = (void *)result;
45447   return jresult;
45448 }
45449
45450
45451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
45452   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45453   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45454
45455   arg1 = (Dali::Vector< float > *)jarg1;
45456   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45457   {
45458     try {
45459       (arg1)->Remove(arg2);
45460     } catch (std::out_of_range& e) {
45461       {
45462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45463       };
45464     } catch (std::exception& e) {
45465       {
45466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45467       };
45468     } catch (...) {
45469       {
45470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45471       };
45472     }
45473   }
45474 }
45475
45476
45477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
45478   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45479   Dali::Vector< float > *arg2 = 0 ;
45480
45481   arg1 = (Dali::Vector< float > *)jarg1;
45482   arg2 = (Dali::Vector< float > *)jarg2;
45483   if (!arg2) {
45484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
45485     return ;
45486   }
45487   {
45488     try {
45489       (arg1)->Swap(*arg2);
45490     } catch (std::out_of_range& e) {
45491       {
45492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45493       };
45494     } catch (std::exception& e) {
45495       {
45496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45497       };
45498     } catch (...) {
45499       {
45500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45501       };
45502     }
45503   }
45504 }
45505
45506
45507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
45508   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45509
45510   arg1 = (Dali::Vector< float > *)jarg1;
45511   {
45512     try {
45513       (arg1)->Clear();
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_VectorFloat_Release(void * jarg1) {
45532   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45533
45534   arg1 = (Dali::Vector< float > *)jarg1;
45535   {
45536     try {
45537       (arg1)->Release();
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 int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
45556   int jresult ;
45557   int result;
45558
45559   result = (int)Dali::Vector< unsigned char >::BaseType;
45560   jresult = (int)result;
45561   return jresult;
45562 }
45563
45564
45565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
45566   void * jresult ;
45567   Dali::Vector< unsigned char > *result = 0 ;
45568
45569   {
45570     try {
45571       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
45572     } catch (std::out_of_range& e) {
45573       {
45574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45575       };
45576     } catch (std::exception& e) {
45577       {
45578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45579       };
45580     } catch (...) {
45581       {
45582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45583       };
45584     }
45585   }
45586   jresult = (void *)result;
45587   return jresult;
45588 }
45589
45590
45591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
45592   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45593
45594   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45595   {
45596     try {
45597       delete arg1;
45598     } catch (std::out_of_range& e) {
45599       {
45600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45601       };
45602     } catch (std::exception& e) {
45603       {
45604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45605       };
45606     } catch (...) {
45607       {
45608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45609       };
45610     }
45611   }
45612 }
45613
45614
45615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
45616   void * jresult ;
45617   Dali::Vector< unsigned char > *arg1 = 0 ;
45618   Dali::Vector< unsigned char > *result = 0 ;
45619
45620   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45621   if (!arg1) {
45622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
45623     return 0;
45624   }
45625   {
45626     try {
45627       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > 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_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
45648   void * jresult ;
45649   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45650   Dali::Vector< unsigned char > *arg2 = 0 ;
45651   Dali::Vector< unsigned char > *result = 0 ;
45652
45653   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45654   arg2 = (Dali::Vector< unsigned char > *)jarg2;
45655   if (!arg2) {
45656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
45657     return 0;
45658   }
45659   {
45660     try {
45661       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > 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_VectorUnsignedChar_Begin(void * jarg1) {
45682   void * jresult ;
45683   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45684   Dali::Vector< unsigned char >::Iterator result;
45685
45686   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45687   {
45688     try {
45689       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
45690     } catch (std::out_of_range& e) {
45691       {
45692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45693       };
45694     } catch (std::exception& e) {
45695       {
45696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45697       };
45698     } catch (...) {
45699       {
45700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45701       };
45702     }
45703   }
45704   jresult = (void *)result;
45705   return jresult;
45706 }
45707
45708
45709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
45710   void * jresult ;
45711   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45712   Dali::Vector< unsigned char >::Iterator result;
45713
45714   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45715   {
45716     try {
45717       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
45718     } catch (std::out_of_range& e) {
45719       {
45720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45721       };
45722     } catch (std::exception& e) {
45723       {
45724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45725       };
45726     } catch (...) {
45727       {
45728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45729       };
45730     }
45731   }
45732   jresult = (void *)result;
45733   return jresult;
45734 }
45735
45736
45737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
45738   void * jresult ;
45739   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45740   Dali::Vector< unsigned char >::SizeType arg2 ;
45741   Dali::Vector< unsigned char >::ItemType *result = 0 ;
45742
45743   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45744   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45745   {
45746     try {
45747       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
45748     } catch (std::out_of_range& e) {
45749       {
45750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45751       };
45752     } catch (std::exception& e) {
45753       {
45754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45755       };
45756     } catch (...) {
45757       {
45758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45759       };
45760     }
45761   }
45762   jresult = (void *)result;
45763   return jresult;
45764 }
45765
45766
45767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
45768   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45769   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
45770   Dali::Vector< unsigned char >::ItemType temp2 ;
45771
45772   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45773   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
45774   arg2 = &temp2;
45775   {
45776     try {
45777       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
45778     } catch (std::out_of_range& e) {
45779       {
45780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45781       };
45782     } catch (std::exception& e) {
45783       {
45784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45785       };
45786     } catch (...) {
45787       {
45788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45789       };
45790     }
45791   }
45792 }
45793
45794
45795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
45796   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45797   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45798   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
45799   Dali::Vector< unsigned char >::ItemType temp3 ;
45800
45801   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45802   arg2 = jarg2;
45803   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
45804   arg3 = &temp3;
45805   {
45806     try {
45807       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
45808     } catch (std::out_of_range& e) {
45809       {
45810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45811       };
45812     } catch (std::exception& e) {
45813       {
45814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45815       };
45816     } catch (...) {
45817       {
45818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45819       };
45820     }
45821   }
45822
45823
45824 }
45825
45826
45827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
45828   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45829   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45830   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45831   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45832
45833   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45834   arg2 = jarg2;
45835   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
45836   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
45837   {
45838     try {
45839       (arg1)->Insert(arg2,arg3,arg4);
45840     } catch (std::out_of_range& e) {
45841       {
45842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45843       };
45844     } catch (std::exception& e) {
45845       {
45846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45847       };
45848     } catch (...) {
45849       {
45850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45851       };
45852     }
45853   }
45854
45855
45856 }
45857
45858
45859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
45860   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45861   Dali::Vector< unsigned char >::SizeType arg2 ;
45862
45863   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45864   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45865   {
45866     try {
45867       (arg1)->Reserve(arg2);
45868     } catch (std::out_of_range& e) {
45869       {
45870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45871       };
45872     } catch (std::exception& e) {
45873       {
45874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45875       };
45876     } catch (...) {
45877       {
45878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45879       };
45880     }
45881   }
45882 }
45883
45884
45885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
45886   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45887   Dali::Vector< unsigned char >::SizeType arg2 ;
45888
45889   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45890   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45891   {
45892     try {
45893       (arg1)->Resize(arg2);
45894     } catch (std::out_of_range& e) {
45895       {
45896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45897       };
45898     } catch (std::exception& e) {
45899       {
45900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45901       };
45902     } catch (...) {
45903       {
45904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45905       };
45906     }
45907   }
45908 }
45909
45910
45911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
45912   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45913   Dali::Vector< unsigned char >::SizeType arg2 ;
45914   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
45915   Dali::Vector< unsigned char >::ItemType temp3 ;
45916
45917   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45918   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45919   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
45920   arg3 = &temp3;
45921   {
45922     try {
45923       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
45924     } catch (std::out_of_range& e) {
45925       {
45926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45927       };
45928     } catch (std::exception& e) {
45929       {
45930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45931       };
45932     } catch (...) {
45933       {
45934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45935       };
45936     }
45937   }
45938 }
45939
45940
45941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
45942   void * jresult ;
45943   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45944   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45945   Dali::Vector< unsigned char >::Iterator result;
45946
45947   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45948   arg2 = jarg2;
45949   {
45950     try {
45951       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
45952     } catch (std::out_of_range& e) {
45953       {
45954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45955       };
45956     } catch (std::exception& e) {
45957       {
45958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45959       };
45960     } catch (...) {
45961       {
45962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45963       };
45964     }
45965   }
45966   jresult = (void *)result;
45967
45968
45969   return jresult;
45970 }
45971
45972
45973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
45974   void * jresult ;
45975   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45976   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45977   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45978   Dali::Vector< unsigned char >::Iterator result;
45979
45980   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45981   arg2 = jarg2;
45982   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
45983   {
45984     try {
45985       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
45986     } catch (std::out_of_range& e) {
45987       {
45988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45989       };
45990     } catch (std::exception& e) {
45991       {
45992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45993       };
45994     } catch (...) {
45995       {
45996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45997       };
45998     }
45999   }
46000   jresult = (void *)result;
46001
46002
46003   return jresult;
46004 }
46005
46006
46007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
46008   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46009   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
46010
46011   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46012   arg2 = jarg2;
46013   {
46014     try {
46015       (arg1)->Remove(arg2);
46016     } catch (std::out_of_range& e) {
46017       {
46018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46019       };
46020     } catch (std::exception& e) {
46021       {
46022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46023       };
46024     } catch (...) {
46025       {
46026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46027       };
46028     }
46029   }
46030
46031
46032 }
46033
46034
46035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
46036   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46037   Dali::Vector< unsigned char > *arg2 = 0 ;
46038
46039   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46040   arg2 = (Dali::Vector< unsigned char > *)jarg2;
46041   if (!arg2) {
46042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
46043     return ;
46044   }
46045   {
46046     try {
46047       (arg1)->Swap(*arg2);
46048     } catch (std::out_of_range& e) {
46049       {
46050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46051       };
46052     } catch (std::exception& e) {
46053       {
46054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46055       };
46056     } catch (...) {
46057       {
46058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46059       };
46060     }
46061   }
46062 }
46063
46064
46065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
46066   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46067
46068   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46069   {
46070     try {
46071       (arg1)->Clear();
46072     } catch (std::out_of_range& e) {
46073       {
46074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46075       };
46076     } catch (std::exception& e) {
46077       {
46078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46079       };
46080     } catch (...) {
46081       {
46082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46083       };
46084     }
46085   }
46086 }
46087
46088
46089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
46090   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46091
46092   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46093   {
46094     try {
46095       (arg1)->Release();
46096     } catch (std::out_of_range& e) {
46097       {
46098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46099       };
46100     } catch (std::exception& e) {
46101       {
46102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46103       };
46104     } catch (...) {
46105       {
46106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46107       };
46108     }
46109   }
46110 }
46111
46112
46113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
46114   int jresult ;
46115   int result;
46116
46117   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
46118   jresult = (int)result;
46119   return jresult;
46120 }
46121
46122
46123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
46124   void * jresult ;
46125   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
46126
46127   {
46128     try {
46129       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
46130     } catch (std::out_of_range& e) {
46131       {
46132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46133       };
46134     } catch (std::exception& e) {
46135       {
46136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46137       };
46138     } catch (...) {
46139       {
46140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46141       };
46142     }
46143   }
46144   jresult = (void *)result;
46145   return jresult;
46146 }
46147
46148
46149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
46150   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46151
46152   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46153   {
46154     try {
46155       delete arg1;
46156     } catch (std::out_of_range& e) {
46157       {
46158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46159       };
46160     } catch (std::exception& e) {
46161       {
46162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46163       };
46164     } catch (...) {
46165       {
46166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46167       };
46168     }
46169   }
46170 }
46171
46172
46173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
46174   void * jresult ;
46175   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
46176   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
46177
46178   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46179   if (!arg1) {
46180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
46181     return 0;
46182   }
46183   {
46184     try {
46185       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
46186     } catch (std::out_of_range& e) {
46187       {
46188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46189       };
46190     } catch (std::exception& e) {
46191       {
46192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46193       };
46194     } catch (...) {
46195       {
46196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46197       };
46198     }
46199   }
46200   jresult = (void *)result;
46201   return jresult;
46202 }
46203
46204
46205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
46206   void * jresult ;
46207   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46208   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
46209   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
46210
46211   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46212   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
46213   if (!arg2) {
46214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
46215     return 0;
46216   }
46217   {
46218     try {
46219       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
46220     } catch (std::out_of_range& e) {
46221       {
46222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46223       };
46224     } catch (std::exception& e) {
46225       {
46226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46227       };
46228     } catch (...) {
46229       {
46230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46231       };
46232     }
46233   }
46234   jresult = (void *)result;
46235   return jresult;
46236 }
46237
46238
46239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
46240   void * jresult ;
46241   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46242   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46243
46244   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46245   {
46246     try {
46247       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
46248     } catch (std::out_of_range& e) {
46249       {
46250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46251       };
46252     } catch (std::exception& e) {
46253       {
46254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46255       };
46256     } catch (...) {
46257       {
46258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46259       };
46260     }
46261   }
46262   jresult = (void *)result;
46263   return jresult;
46264 }
46265
46266
46267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
46268   void * jresult ;
46269   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46270   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46271
46272   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46273   {
46274     try {
46275       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
46276     } catch (std::out_of_range& e) {
46277       {
46278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46279       };
46280     } catch (std::exception& e) {
46281       {
46282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46283       };
46284     } catch (...) {
46285       {
46286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46287       };
46288     }
46289   }
46290   jresult = (void *)result;
46291   return jresult;
46292 }
46293
46294
46295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46296   void * jresult ;
46297   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46298   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46299   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
46300
46301   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46302   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46303   {
46304     try {
46305       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
46306     } catch (std::out_of_range& e) {
46307       {
46308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46309       };
46310     } catch (std::exception& e) {
46311       {
46312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46313       };
46314     } catch (...) {
46315       {
46316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46317       };
46318     }
46319   }
46320   jresult = (void *)result;
46321   return jresult;
46322 }
46323
46324
46325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
46326   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46327   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
46328
46329   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46330   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
46331   if (!arg2) {
46332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
46333     return ;
46334   }
46335   {
46336     try {
46337       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
46338     } catch (std::out_of_range& e) {
46339       {
46340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46341       };
46342     } catch (std::exception& e) {
46343       {
46344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46345       };
46346     } catch (...) {
46347       {
46348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46349       };
46350     }
46351   }
46352 }
46353
46354
46355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
46356   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46357   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46358   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
46359
46360   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46361   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46362   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
46363   if (!arg3) {
46364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
46365     return ;
46366   }
46367   {
46368     try {
46369       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
46370     } catch (std::out_of_range& e) {
46371       {
46372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46373       };
46374     } catch (std::exception& e) {
46375       {
46376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46377       };
46378     } catch (...) {
46379       {
46380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46381       };
46382     }
46383   }
46384 }
46385
46386
46387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46388   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46389   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46390   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46391   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46392
46393   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46394   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46395   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
46396   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
46397   {
46398     try {
46399       (arg1)->Insert(arg2,arg3,arg4);
46400     } catch (std::out_of_range& e) {
46401       {
46402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46403       };
46404     } catch (std::exception& e) {
46405       {
46406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46407       };
46408     } catch (...) {
46409       {
46410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46411       };
46412     }
46413   }
46414 }
46415
46416
46417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
46418   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46419   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46420
46421   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46422   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46423   {
46424     try {
46425       (arg1)->Reserve(arg2);
46426     } catch (std::out_of_range& e) {
46427       {
46428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46429       };
46430     } catch (std::exception& e) {
46431       {
46432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46433       };
46434     } catch (...) {
46435       {
46436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46437       };
46438     }
46439   }
46440 }
46441
46442
46443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46444   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46445   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46446
46447   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46448   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46449   {
46450     try {
46451       (arg1)->Resize(arg2);
46452     } catch (std::out_of_range& e) {
46453       {
46454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46455       };
46456     } catch (std::exception& e) {
46457       {
46458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46459       };
46460     } catch (...) {
46461       {
46462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46463       };
46464     }
46465   }
46466 }
46467
46468
46469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
46470   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46471   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46472   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
46473
46474   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46475   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46476   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
46477   if (!arg3) {
46478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
46479     return ;
46480   }
46481   {
46482     try {
46483       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
46484     } catch (std::out_of_range& e) {
46485       {
46486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46487       };
46488     } catch (std::exception& e) {
46489       {
46490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46491       };
46492     } catch (...) {
46493       {
46494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46495       };
46496     }
46497   }
46498 }
46499
46500
46501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
46502   void * jresult ;
46503   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46504   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46505   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46506
46507   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46508   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46509   {
46510     try {
46511       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
46512     } catch (std::out_of_range& e) {
46513       {
46514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46515       };
46516     } catch (std::exception& e) {
46517       {
46518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46519       };
46520     } catch (...) {
46521       {
46522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46523       };
46524     }
46525   }
46526   jresult = (void *)result;
46527   return jresult;
46528 }
46529
46530
46531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46532   void * jresult ;
46533   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46534   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46535   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46536   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46537
46538   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46539   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46540   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
46541   {
46542     try {
46543       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
46544     } catch (std::out_of_range& e) {
46545       {
46546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46547       };
46548     } catch (std::exception& e) {
46549       {
46550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46551       };
46552     } catch (...) {
46553       {
46554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46555       };
46556     }
46557   }
46558   jresult = (void *)result;
46559   return jresult;
46560 }
46561
46562
46563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
46564   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46565   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46566
46567   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46568   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46569   {
46570     try {
46571       (arg1)->Remove(arg2);
46572     } catch (std::out_of_range& e) {
46573       {
46574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46575       };
46576     } catch (std::exception& e) {
46577       {
46578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46579       };
46580     } catch (...) {
46581       {
46582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46583       };
46584     }
46585   }
46586 }
46587
46588
46589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
46590   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46591   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
46592
46593   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46594   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
46595   if (!arg2) {
46596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
46597     return ;
46598   }
46599   {
46600     try {
46601       (arg1)->Swap(*arg2);
46602     } catch (std::out_of_range& e) {
46603       {
46604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46605       };
46606     } catch (std::exception& e) {
46607       {
46608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46609       };
46610     } catch (...) {
46611       {
46612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46613       };
46614     }
46615   }
46616 }
46617
46618
46619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
46620   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46621
46622   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46623   {
46624     try {
46625       (arg1)->Clear();
46626     } catch (std::out_of_range& e) {
46627       {
46628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46629       };
46630     } catch (std::exception& e) {
46631       {
46632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46633       };
46634     } catch (...) {
46635       {
46636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46637       };
46638     }
46639   }
46640 }
46641
46642
46643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
46644   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46645
46646   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46647   {
46648     try {
46649       (arg1)->Release();
46650     } catch (std::out_of_range& e) {
46651       {
46652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46653       };
46654     } catch (std::exception& e) {
46655       {
46656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46657       };
46658     } catch (...) {
46659       {
46660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46661       };
46662     }
46663   }
46664 }
46665
46666
46667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
46668   void * jresult ;
46669   Dali::Signal< void () > *result = 0 ;
46670
46671   {
46672     try {
46673       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
46674     } catch (std::out_of_range& e) {
46675       {
46676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46677       };
46678     } catch (std::exception& e) {
46679       {
46680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46681       };
46682     } catch (...) {
46683       {
46684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46685       };
46686     }
46687   }
46688   jresult = (void *)result;
46689   return jresult;
46690 }
46691
46692
46693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
46694   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46695
46696   arg1 = (Dali::Signal< void () > *)jarg1;
46697   {
46698     try {
46699       delete arg1;
46700     } catch (std::out_of_range& e) {
46701       {
46702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46703       };
46704     } catch (std::exception& e) {
46705       {
46706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46707       };
46708     } catch (...) {
46709       {
46710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46711       };
46712     }
46713   }
46714 }
46715
46716
46717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
46718   unsigned int jresult ;
46719   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46720   bool result;
46721
46722   arg1 = (Dali::Signal< void () > *)jarg1;
46723   {
46724     try {
46725       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
46726     } catch (std::out_of_range& e) {
46727       {
46728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46729       };
46730     } catch (std::exception& e) {
46731       {
46732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46733       };
46734     } catch (...) {
46735       {
46736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46737       };
46738     }
46739   }
46740   jresult = result;
46741   return jresult;
46742 }
46743
46744
46745 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
46746   unsigned long jresult ;
46747   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46748   std::size_t result;
46749
46750   arg1 = (Dali::Signal< void () > *)jarg1;
46751   {
46752     try {
46753       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
46754     } catch (std::out_of_range& e) {
46755       {
46756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46757       };
46758     } catch (std::exception& e) {
46759       {
46760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46761       };
46762     } catch (...) {
46763       {
46764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46765       };
46766     }
46767   }
46768   jresult = (unsigned long)result;
46769   return jresult;
46770 }
46771
46772
46773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
46774   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46775   void (*arg2)() = (void (*)()) 0 ;
46776
46777   arg1 = (Dali::Signal< void () > *)jarg1;
46778   arg2 = (void (*)())jarg2;
46779   {
46780     try {
46781       (arg1)->Connect(arg2);
46782     } catch (std::out_of_range& e) {
46783       {
46784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46785       };
46786     } catch (std::exception& e) {
46787       {
46788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46789       };
46790     } catch (...) {
46791       {
46792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46793       };
46794     }
46795   }
46796 }
46797
46798
46799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
46800   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46801   void (*arg2)() = (void (*)()) 0 ;
46802
46803   arg1 = (Dali::Signal< void () > *)jarg1;
46804   arg2 = (void (*)())jarg2;
46805   {
46806     try {
46807       (arg1)->Disconnect(arg2);
46808     } catch (std::out_of_range& e) {
46809       {
46810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46811       };
46812     } catch (std::exception& e) {
46813       {
46814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46815       };
46816     } catch (...) {
46817       {
46818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46819       };
46820     }
46821   }
46822 }
46823
46824
46825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
46826   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46827   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
46828   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
46829
46830   arg1 = (Dali::Signal< void () > *)jarg1;
46831   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
46832   arg3 = (Dali::FunctorDelegate *)jarg3;
46833   {
46834     try {
46835       (arg1)->Connect(arg2,arg3);
46836     } catch (std::out_of_range& e) {
46837       {
46838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46839       };
46840     } catch (std::exception& e) {
46841       {
46842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46843       };
46844     } catch (...) {
46845       {
46846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46847       };
46848     }
46849   }
46850 }
46851
46852
46853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
46854   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46855
46856   arg1 = (Dali::Signal< void () > *)jarg1;
46857   {
46858     try {
46859       (arg1)->Emit();
46860     } catch (std::out_of_range& e) {
46861       {
46862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46863       };
46864     } catch (std::exception& e) {
46865       {
46866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46867       };
46868     } catch (...) {
46869       {
46870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46871       };
46872     }
46873   }
46874 }
46875
46876
46877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
46878   unsigned int jresult ;
46879   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46880   bool result;
46881
46882   arg1 = (Dali::Signal< void (float) > *)jarg1;
46883   {
46884     try {
46885       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
46886     } catch (std::out_of_range& e) {
46887       {
46888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46889       };
46890     } catch (std::exception& e) {
46891       {
46892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46893       };
46894     } catch (...) {
46895       {
46896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46897       };
46898     }
46899   }
46900   jresult = result;
46901   return jresult;
46902 }
46903
46904
46905 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
46906   unsigned long jresult ;
46907   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46908   std::size_t result;
46909
46910   arg1 = (Dali::Signal< void (float) > *)jarg1;
46911   {
46912     try {
46913       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
46914     } catch (std::out_of_range& e) {
46915       {
46916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46917       };
46918     } catch (std::exception& e) {
46919       {
46920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46921       };
46922     } catch (...) {
46923       {
46924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46925       };
46926     }
46927   }
46928   jresult = (unsigned long)result;
46929   return jresult;
46930 }
46931
46932
46933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
46934   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46935   void (*arg2)(float) = (void (*)(float)) 0 ;
46936
46937   arg1 = (Dali::Signal< void (float) > *)jarg1;
46938   arg2 = (void (*)(float))jarg2;
46939   {
46940     try {
46941       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
46942     } catch (std::out_of_range& e) {
46943       {
46944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46945       };
46946     } catch (std::exception& e) {
46947       {
46948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46949       };
46950     } catch (...) {
46951       {
46952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46953       };
46954     }
46955   }
46956 }
46957
46958
46959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
46960   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46961   void (*arg2)(float) = (void (*)(float)) 0 ;
46962
46963   arg1 = (Dali::Signal< void (float) > *)jarg1;
46964   arg2 = (void (*)(float))jarg2;
46965   {
46966     try {
46967       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
46968     } catch (std::out_of_range& e) {
46969       {
46970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46971       };
46972     } catch (std::exception& e) {
46973       {
46974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46975       };
46976     } catch (...) {
46977       {
46978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46979       };
46980     }
46981   }
46982 }
46983
46984
46985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
46986   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46987   float arg2 ;
46988
46989   arg1 = (Dali::Signal< void (float) > *)jarg1;
46990   arg2 = (float)jarg2;
46991   {
46992     try {
46993       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
46994     } catch (std::out_of_range& e) {
46995       {
46996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46997       };
46998     } catch (std::exception& e) {
46999       {
47000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47001       };
47002     } catch (...) {
47003       {
47004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47005       };
47006     }
47007   }
47008 }
47009
47010
47011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
47012   void * jresult ;
47013   Dali::Signal< void (float) > *result = 0 ;
47014
47015   {
47016     try {
47017       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
47018     } catch (std::out_of_range& e) {
47019       {
47020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47021       };
47022     } catch (std::exception& e) {
47023       {
47024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47025       };
47026     } catch (...) {
47027       {
47028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47029       };
47030     }
47031   }
47032   jresult = (void *)result;
47033   return jresult;
47034 }
47035
47036
47037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
47038   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
47039
47040   arg1 = (Dali::Signal< void (float) > *)jarg1;
47041   {
47042     try {
47043       delete arg1;
47044     } catch (std::out_of_range& e) {
47045       {
47046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47047       };
47048     } catch (std::exception& e) {
47049       {
47050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47051       };
47052     } catch (...) {
47053       {
47054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47055       };
47056     }
47057   }
47058 }
47059
47060
47061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
47062   unsigned int jresult ;
47063   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47064   bool result;
47065
47066   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47067   {
47068     try {
47069       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
47070     } catch (std::out_of_range& e) {
47071       {
47072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47073       };
47074     } catch (std::exception& e) {
47075       {
47076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47077       };
47078     } catch (...) {
47079       {
47080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47081       };
47082     }
47083   }
47084   jresult = result;
47085   return jresult;
47086 }
47087
47088
47089 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
47090   unsigned long jresult ;
47091   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47092   std::size_t result;
47093
47094   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47095   {
47096     try {
47097       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
47098     } catch (std::out_of_range& e) {
47099       {
47100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47101       };
47102     } catch (std::exception& e) {
47103       {
47104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47105       };
47106     } catch (...) {
47107       {
47108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47109       };
47110     }
47111   }
47112   jresult = (unsigned long)result;
47113   return jresult;
47114 }
47115
47116
47117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
47118   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47119   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
47120
47121   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47122   arg2 = (void (*)(Dali::BaseHandle))jarg2;
47123   {
47124     try {
47125       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
47126     } catch (std::out_of_range& e) {
47127       {
47128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47129       };
47130     } catch (std::exception& e) {
47131       {
47132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47133       };
47134     } catch (...) {
47135       {
47136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47137       };
47138     }
47139   }
47140 }
47141
47142
47143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
47144   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47145   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
47146
47147   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47148   arg2 = (void (*)(Dali::BaseHandle))jarg2;
47149   {
47150     try {
47151       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
47152     } catch (std::out_of_range& e) {
47153       {
47154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47155       };
47156     } catch (std::exception& e) {
47157       {
47158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47159       };
47160     } catch (...) {
47161       {
47162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47163       };
47164     }
47165   }
47166 }
47167
47168
47169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
47170   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47171   Dali::BaseHandle arg2 ;
47172   Dali::BaseHandle *argp2 ;
47173
47174   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47175   argp2 = (Dali::BaseHandle *)jarg2;
47176   if (!argp2) {
47177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47178     return ;
47179   }
47180   arg2 = *argp2;
47181   {
47182     try {
47183       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
47184     } catch (std::out_of_range& e) {
47185       {
47186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47187       };
47188     } catch (std::exception& e) {
47189       {
47190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47191       };
47192     } catch (...) {
47193       {
47194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47195       };
47196     }
47197   }
47198 }
47199
47200
47201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
47202   void * jresult ;
47203   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
47204
47205   {
47206     try {
47207       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
47208     } catch (std::out_of_range& e) {
47209       {
47210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47211       };
47212     } catch (std::exception& e) {
47213       {
47214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47215       };
47216     } catch (...) {
47217       {
47218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47219       };
47220     }
47221   }
47222   jresult = (void *)result;
47223   return jresult;
47224 }
47225
47226
47227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
47228   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47229
47230   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47231   {
47232     try {
47233       delete arg1;
47234     } catch (std::out_of_range& e) {
47235       {
47236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47237       };
47238     } catch (std::exception& e) {
47239       {
47240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47241       };
47242     } catch (...) {
47243       {
47244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47245       };
47246     }
47247   }
47248 }
47249
47250
47251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
47252   unsigned int jresult ;
47253   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47254   bool result;
47255
47256   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47257   {
47258     try {
47259       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
47260     } catch (std::out_of_range& e) {
47261       {
47262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47263       };
47264     } catch (std::exception& e) {
47265       {
47266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47267       };
47268     } catch (...) {
47269       {
47270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47271       };
47272     }
47273   }
47274   jresult = result;
47275   return jresult;
47276 }
47277
47278
47279 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
47280   unsigned long jresult ;
47281   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47282   std::size_t result;
47283
47284   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47285   {
47286     try {
47287       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
47288     } catch (std::out_of_range& e) {
47289       {
47290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47291       };
47292     } catch (std::exception& e) {
47293       {
47294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47295       };
47296     } catch (...) {
47297       {
47298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47299       };
47300     }
47301   }
47302   jresult = (unsigned long)result;
47303   return jresult;
47304 }
47305
47306
47307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
47308   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47309   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
47310
47311   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47312   arg2 = (void (*)(Dali::RefObject const *))jarg2;
47313   {
47314     try {
47315       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
47316     } catch (std::out_of_range& e) {
47317       {
47318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47319       };
47320     } catch (std::exception& e) {
47321       {
47322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47323       };
47324     } catch (...) {
47325       {
47326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47327       };
47328     }
47329   }
47330 }
47331
47332
47333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
47334   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47335   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
47336
47337   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47338   arg2 = (void (*)(Dali::RefObject const *))jarg2;
47339   {
47340     try {
47341       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
47342     } catch (std::out_of_range& e) {
47343       {
47344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47345       };
47346     } catch (std::exception& e) {
47347       {
47348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47349       };
47350     } catch (...) {
47351       {
47352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47353       };
47354     }
47355   }
47356 }
47357
47358
47359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
47360   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47361   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
47362
47363   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47364   arg2 = (Dali::RefObject *)jarg2;
47365   {
47366     try {
47367       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
47368     } catch (std::out_of_range& e) {
47369       {
47370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47371       };
47372     } catch (std::exception& e) {
47373       {
47374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47375       };
47376     } catch (...) {
47377       {
47378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47379       };
47380     }
47381   }
47382 }
47383
47384
47385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
47386   void * jresult ;
47387   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
47388
47389   {
47390     try {
47391       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
47392     } catch (std::out_of_range& e) {
47393       {
47394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47395       };
47396     } catch (std::exception& e) {
47397       {
47398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47399       };
47400     } catch (...) {
47401       {
47402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47403       };
47404     }
47405   }
47406   jresult = (void *)result;
47407   return jresult;
47408 }
47409
47410
47411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
47412   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47413
47414   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47415   {
47416     try {
47417       delete arg1;
47418     } catch (std::out_of_range& e) {
47419       {
47420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47421       };
47422     } catch (std::exception& e) {
47423       {
47424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47425       };
47426     } catch (...) {
47427       {
47428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47429       };
47430     }
47431   }
47432 }
47433
47434
47435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
47436   unsigned int jresult ;
47437   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47438   bool result;
47439
47440   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47441   {
47442     try {
47443       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
47444     } catch (std::out_of_range& e) {
47445       {
47446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47447       };
47448     } catch (std::exception& e) {
47449       {
47450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47451       };
47452     } catch (...) {
47453       {
47454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47455       };
47456     }
47457   }
47458   jresult = result;
47459   return jresult;
47460 }
47461
47462
47463 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
47464   unsigned long jresult ;
47465   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47466   std::size_t result;
47467
47468   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47469   {
47470     try {
47471       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
47472     } catch (std::out_of_range& e) {
47473       {
47474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47475       };
47476     } catch (std::exception& e) {
47477       {
47478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47479       };
47480     } catch (...) {
47481       {
47482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47483       };
47484     }
47485   }
47486   jresult = (unsigned long)result;
47487   return jresult;
47488 }
47489
47490
47491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
47492   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47493   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
47494
47495   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47496   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
47497   {
47498     try {
47499       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
47500     } catch (std::out_of_range& e) {
47501       {
47502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47503       };
47504     } catch (std::exception& e) {
47505       {
47506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47507       };
47508     } catch (...) {
47509       {
47510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47511       };
47512     }
47513   }
47514 }
47515
47516
47517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
47518   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47519   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
47520
47521   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47522   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
47523   {
47524     try {
47525       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
47526     } catch (std::out_of_range& e) {
47527       {
47528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47529       };
47530     } catch (std::exception& e) {
47531       {
47532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47533       };
47534     } catch (...) {
47535       {
47536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47537       };
47538     }
47539   }
47540 }
47541
47542
47543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
47544   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47545   Dali::PropertyNotification *arg2 = 0 ;
47546
47547   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47548   arg2 = (Dali::PropertyNotification *)jarg2;
47549   if (!arg2) {
47550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
47551     return ;
47552   }
47553   {
47554     try {
47555       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
47556     } catch (std::out_of_range& e) {
47557       {
47558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47559       };
47560     } catch (std::exception& e) {
47561       {
47562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47563       };
47564     } catch (...) {
47565       {
47566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47567       };
47568     }
47569   }
47570 }
47571
47572
47573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
47574   void * jresult ;
47575   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
47576
47577   {
47578     try {
47579       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
47580     } catch (std::out_of_range& e) {
47581       {
47582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47583       };
47584     } catch (std::exception& e) {
47585       {
47586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47587       };
47588     } catch (...) {
47589       {
47590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47591       };
47592     }
47593   }
47594   jresult = (void *)result;
47595   return jresult;
47596 }
47597
47598
47599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
47600   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47601
47602   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47603   {
47604     try {
47605       delete arg1;
47606     } catch (std::out_of_range& e) {
47607       {
47608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47609       };
47610     } catch (std::exception& e) {
47611       {
47612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47613       };
47614     } catch (...) {
47615       {
47616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47617       };
47618     }
47619   }
47620 }
47621
47622
47623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
47624   unsigned int jresult ;
47625   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47626   bool result;
47627
47628   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47629   {
47630     try {
47631       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
47632     } catch (std::out_of_range& e) {
47633       {
47634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47635       };
47636     } catch (std::exception& e) {
47637       {
47638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47639       };
47640     } catch (...) {
47641       {
47642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47643       };
47644     }
47645   }
47646   jresult = result;
47647   return jresult;
47648 }
47649
47650
47651 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
47652   unsigned long jresult ;
47653   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47654   std::size_t result;
47655
47656   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47657   {
47658     try {
47659       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
47660     } catch (std::out_of_range& e) {
47661       {
47662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47663       };
47664     } catch (std::exception& e) {
47665       {
47666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47667       };
47668     } catch (...) {
47669       {
47670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47671       };
47672     }
47673   }
47674   jresult = (unsigned long)result;
47675   return jresult;
47676 }
47677
47678
47679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
47680   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47681   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
47682
47683   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47684   arg2 = (void (*)(Dali::Image))jarg2;
47685   {
47686     try {
47687       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
47688     } catch (std::out_of_range& e) {
47689       {
47690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47691       };
47692     } catch (std::exception& e) {
47693       {
47694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47695       };
47696     } catch (...) {
47697       {
47698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47699       };
47700     }
47701   }
47702 }
47703
47704
47705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
47706   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47707   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
47708
47709   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47710   arg2 = (void (*)(Dali::Image))jarg2;
47711   {
47712     try {
47713       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
47714     } catch (std::out_of_range& e) {
47715       {
47716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47717       };
47718     } catch (std::exception& e) {
47719       {
47720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47721       };
47722     } catch (...) {
47723       {
47724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47725       };
47726     }
47727   }
47728 }
47729
47730
47731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
47732   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47733   Dali::Image arg2 ;
47734   Dali::Image *argp2 ;
47735
47736   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47737   argp2 = (Dali::Image *)jarg2;
47738   if (!argp2) {
47739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
47740     return ;
47741   }
47742   arg2 = *argp2;
47743   {
47744     try {
47745       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
47746     } catch (std::out_of_range& e) {
47747       {
47748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47749       };
47750     } catch (std::exception& e) {
47751       {
47752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47753       };
47754     } catch (...) {
47755       {
47756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47757       };
47758     }
47759   }
47760 }
47761
47762
47763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
47764   void * jresult ;
47765   Dali::Signal< void (Dali::Image) > *result = 0 ;
47766
47767   {
47768     try {
47769       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
47770     } catch (std::out_of_range& e) {
47771       {
47772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47773       };
47774     } catch (std::exception& e) {
47775       {
47776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47777       };
47778     } catch (...) {
47779       {
47780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47781       };
47782     }
47783   }
47784   jresult = (void *)result;
47785   return jresult;
47786 }
47787
47788
47789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
47790   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47791
47792   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47793   {
47794     try {
47795       delete arg1;
47796     } catch (std::out_of_range& e) {
47797       {
47798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47799       };
47800     } catch (std::exception& e) {
47801       {
47802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47803       };
47804     } catch (...) {
47805       {
47806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47807       };
47808     }
47809   }
47810 }
47811
47812
47813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
47814   void * jresult ;
47815   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
47816
47817   {
47818     try {
47819       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
47820     } catch (std::out_of_range& e) {
47821       {
47822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47823       };
47824     } catch (std::exception& e) {
47825       {
47826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47827       };
47828     } catch (...) {
47829       {
47830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47831       };
47832     }
47833   }
47834   jresult = (void *)result;
47835   return jresult;
47836 }
47837
47838
47839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
47840   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
47841
47842   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
47843   {
47844     try {
47845       delete arg1;
47846     } catch (std::out_of_range& e) {
47847       {
47848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47849       };
47850     } catch (std::exception& e) {
47851       {
47852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47853       };
47854     } catch (...) {
47855       {
47856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47857       };
47858     }
47859   }
47860 }
47861
47862
47863 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
47864   unsigned int jresult ;
47865   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47866   bool result;
47867
47868   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47869   {
47870     try {
47871       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);
47872     } catch (std::out_of_range& e) {
47873       {
47874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47875       };
47876     } catch (std::exception& e) {
47877       {
47878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47879       };
47880     } catch (...) {
47881       {
47882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47883       };
47884     }
47885   }
47886   jresult = result;
47887   return jresult;
47888 }
47889
47890
47891 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
47892   unsigned long jresult ;
47893   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47894   std::size_t result;
47895
47896   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47897   {
47898     try {
47899       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);
47900     } catch (std::out_of_range& e) {
47901       {
47902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47903       };
47904     } catch (std::exception& e) {
47905       {
47906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47907       };
47908     } catch (...) {
47909       {
47910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47911       };
47912     }
47913   }
47914   jresult = (unsigned long)result;
47915   return jresult;
47916 }
47917
47918
47919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
47920   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47921   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
47922
47923   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47924   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
47925   {
47926     try {
47927       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
47928     } catch (std::out_of_range& e) {
47929       {
47930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47931       };
47932     } catch (std::exception& e) {
47933       {
47934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47935       };
47936     } catch (...) {
47937       {
47938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47939       };
47940     }
47941   }
47942 }
47943
47944
47945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
47946   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47947   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
47948
47949   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47950   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
47951   {
47952     try {
47953       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
47954     } catch (std::out_of_range& e) {
47955       {
47956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47957       };
47958     } catch (std::exception& e) {
47959       {
47960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47961       };
47962     } catch (...) {
47963       {
47964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47965       };
47966     }
47967   }
47968 }
47969
47970
47971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
47972   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47973   Dali::Actor arg2 ;
47974   Dali::LongPressGesture *arg3 = 0 ;
47975   Dali::Actor *argp2 ;
47976
47977   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47978   argp2 = (Dali::Actor *)jarg2;
47979   if (!argp2) {
47980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47981     return ;
47982   }
47983   arg2 = *argp2;
47984   arg3 = (Dali::LongPressGesture *)jarg3;
47985   if (!arg3) {
47986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
47987     return ;
47988   }
47989   {
47990     try {
47991       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
47992     } catch (std::out_of_range& e) {
47993       {
47994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47995       };
47996     } catch (std::exception& e) {
47997       {
47998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47999       };
48000     } catch (...) {
48001       {
48002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48003       };
48004     }
48005   }
48006 }
48007
48008
48009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
48010   void * jresult ;
48011   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
48012
48013   {
48014     try {
48015       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
48016     } catch (std::out_of_range& e) {
48017       {
48018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48019       };
48020     } catch (std::exception& e) {
48021       {
48022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48023       };
48024     } catch (...) {
48025       {
48026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48027       };
48028     }
48029   }
48030   jresult = (void *)result;
48031   return jresult;
48032 }
48033
48034
48035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
48036   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
48037
48038   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
48039   {
48040     try {
48041       delete arg1;
48042     } catch (std::out_of_range& e) {
48043       {
48044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48045       };
48046     } catch (std::exception& e) {
48047       {
48048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48049       };
48050     } catch (...) {
48051       {
48052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48053       };
48054     }
48055   }
48056 }
48057
48058
48059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
48060   unsigned int jresult ;
48061   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48062   bool result;
48063
48064   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48065   {
48066     try {
48067       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);
48068     } catch (std::out_of_range& e) {
48069       {
48070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48071       };
48072     } catch (std::exception& e) {
48073       {
48074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48075       };
48076     } catch (...) {
48077       {
48078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48079       };
48080     }
48081   }
48082   jresult = result;
48083   return jresult;
48084 }
48085
48086
48087 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
48088   unsigned long jresult ;
48089   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48090   std::size_t result;
48091
48092   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48093   {
48094     try {
48095       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);
48096     } catch (std::out_of_range& e) {
48097       {
48098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48099       };
48100     } catch (std::exception& e) {
48101       {
48102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48103       };
48104     } catch (...) {
48105       {
48106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48107       };
48108     }
48109   }
48110   jresult = (unsigned long)result;
48111   return jresult;
48112 }
48113
48114
48115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
48116   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48117   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
48118
48119   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48120   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
48121   {
48122     try {
48123       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48124     } catch (std::out_of_range& e) {
48125       {
48126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48127       };
48128     } catch (std::exception& e) {
48129       {
48130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48131       };
48132     } catch (...) {
48133       {
48134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48135       };
48136     }
48137   }
48138 }
48139
48140
48141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
48142   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48143   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
48144
48145   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48146   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
48147   {
48148     try {
48149       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48150     } catch (std::out_of_range& e) {
48151       {
48152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48153       };
48154     } catch (std::exception& e) {
48155       {
48156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48157       };
48158     } catch (...) {
48159       {
48160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48161       };
48162     }
48163   }
48164 }
48165
48166
48167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
48168   unsigned int jresult ;
48169   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48170   Dali::Actor arg2 ;
48171   Dali::TouchData *arg3 = 0 ;
48172   Dali::Actor *argp2 ;
48173   bool result;
48174
48175   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48176   argp2 = (Dali::Actor *)jarg2;
48177   if (!argp2) {
48178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48179     return 0;
48180   }
48181   arg2 = *argp2;
48182   arg3 = (Dali::TouchData *)jarg3;
48183   if (!arg3) {
48184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
48185     return 0;
48186   }
48187   {
48188     try {
48189       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
48190     } catch (std::out_of_range& e) {
48191       {
48192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48193       };
48194     } catch (std::exception& e) {
48195       {
48196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48197       };
48198     } catch (...) {
48199       {
48200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48201       };
48202     }
48203   }
48204   jresult = result;
48205   return jresult;
48206 }
48207
48208
48209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
48210   void * jresult ;
48211   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
48212
48213   {
48214     try {
48215       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
48216     } catch (std::out_of_range& e) {
48217       {
48218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48219       };
48220     } catch (std::exception& e) {
48221       {
48222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48223       };
48224     } catch (...) {
48225       {
48226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48227       };
48228     }
48229   }
48230   jresult = (void *)result;
48231   return jresult;
48232 }
48233
48234
48235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
48236   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48237
48238   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48239   {
48240     try {
48241       delete arg1;
48242     } catch (std::out_of_range& e) {
48243       {
48244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48245       };
48246     } catch (std::exception& e) {
48247       {
48248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48249       };
48250     } catch (...) {
48251       {
48252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48253       };
48254     }
48255   }
48256 }
48257
48258
48259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
48260   unsigned int jresult ;
48261   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48262   bool result;
48263
48264   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48265   {
48266     try {
48267       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);
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 = result;
48283   return jresult;
48284 }
48285
48286
48287 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
48288   unsigned long jresult ;
48289   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48290   std::size_t result;
48291
48292   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48293   {
48294     try {
48295       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);
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 = (unsigned long)result;
48311   return jresult;
48312 }
48313
48314
48315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
48316   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48317   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
48318
48319   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48320   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
48321   {
48322     try {
48323       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48324     } catch (std::out_of_range& e) {
48325       {
48326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48327       };
48328     } catch (std::exception& e) {
48329       {
48330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48331       };
48332     } catch (...) {
48333       {
48334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48335       };
48336     }
48337   }
48338 }
48339
48340
48341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
48342   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48343   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
48344
48345   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48346   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
48347   {
48348     try {
48349       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48350     } catch (std::out_of_range& e) {
48351       {
48352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48353       };
48354     } catch (std::exception& e) {
48355       {
48356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48357       };
48358     } catch (...) {
48359       {
48360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48361       };
48362     }
48363   }
48364 }
48365
48366
48367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
48368   unsigned int jresult ;
48369   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48370   Dali::Actor arg2 ;
48371   Dali::HoverEvent *arg3 = 0 ;
48372   Dali::Actor *argp2 ;
48373   bool result;
48374
48375   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48376   argp2 = (Dali::Actor *)jarg2;
48377   if (!argp2) {
48378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48379     return 0;
48380   }
48381   arg2 = *argp2;
48382   arg3 = (Dali::HoverEvent *)jarg3;
48383   if (!arg3) {
48384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
48385     return 0;
48386   }
48387   {
48388     try {
48389       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
48390     } catch (std::out_of_range& e) {
48391       {
48392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48393       };
48394     } catch (std::exception& e) {
48395       {
48396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48397       };
48398     } catch (...) {
48399       {
48400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48401       };
48402     }
48403   }
48404   jresult = result;
48405   return jresult;
48406 }
48407
48408
48409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
48410   void * jresult ;
48411   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
48412
48413   {
48414     try {
48415       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
48416     } catch (std::out_of_range& e) {
48417       {
48418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48419       };
48420     } catch (std::exception& e) {
48421       {
48422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48423       };
48424     } catch (...) {
48425       {
48426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48427       };
48428     }
48429   }
48430   jresult = (void *)result;
48431   return jresult;
48432 }
48433
48434
48435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
48436   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48437
48438   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48439   {
48440     try {
48441       delete arg1;
48442     } catch (std::out_of_range& e) {
48443       {
48444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48445       };
48446     } catch (std::exception& e) {
48447       {
48448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48449       };
48450     } catch (...) {
48451       {
48452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48453       };
48454     }
48455   }
48456 }
48457
48458
48459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
48460   unsigned int jresult ;
48461   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48462   bool result;
48463
48464   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48465   {
48466     try {
48467       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);
48468     } catch (std::out_of_range& e) {
48469       {
48470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48471       };
48472     } catch (std::exception& e) {
48473       {
48474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48475       };
48476     } catch (...) {
48477       {
48478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48479       };
48480     }
48481   }
48482   jresult = result;
48483   return jresult;
48484 }
48485
48486
48487 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
48488   unsigned long jresult ;
48489   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48490   std::size_t result;
48491
48492   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48493   {
48494     try {
48495       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);
48496     } catch (std::out_of_range& e) {
48497       {
48498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48499       };
48500     } catch (std::exception& e) {
48501       {
48502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48503       };
48504     } catch (...) {
48505       {
48506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48507       };
48508     }
48509   }
48510   jresult = (unsigned long)result;
48511   return jresult;
48512 }
48513
48514
48515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
48516   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48517   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
48518
48519   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48520   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
48521   {
48522     try {
48523       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48524     } catch (std::out_of_range& e) {
48525       {
48526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48527       };
48528     } catch (std::exception& e) {
48529       {
48530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48531       };
48532     } catch (...) {
48533       {
48534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48535       };
48536     }
48537   }
48538 }
48539
48540
48541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
48542   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48543   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
48544
48545   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48546   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
48547   {
48548     try {
48549       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48550     } catch (std::out_of_range& e) {
48551       {
48552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48553       };
48554     } catch (std::exception& e) {
48555       {
48556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48557       };
48558     } catch (...) {
48559       {
48560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48561       };
48562     }
48563   }
48564 }
48565
48566
48567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
48568   unsigned int jresult ;
48569   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48570   Dali::Actor arg2 ;
48571   Dali::WheelEvent *arg3 = 0 ;
48572   Dali::Actor *argp2 ;
48573   bool result;
48574
48575   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48576   argp2 = (Dali::Actor *)jarg2;
48577   if (!argp2) {
48578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48579     return 0;
48580   }
48581   arg2 = *argp2;
48582   arg3 = (Dali::WheelEvent *)jarg3;
48583   if (!arg3) {
48584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
48585     return 0;
48586   }
48587   {
48588     try {
48589       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
48590     } catch (std::out_of_range& e) {
48591       {
48592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48593       };
48594     } catch (std::exception& e) {
48595       {
48596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48597       };
48598     } catch (...) {
48599       {
48600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48601       };
48602     }
48603   }
48604   jresult = result;
48605   return jresult;
48606 }
48607
48608
48609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
48610   void * jresult ;
48611   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
48612
48613   {
48614     try {
48615       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
48616     } catch (std::out_of_range& e) {
48617       {
48618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48619       };
48620     } catch (std::exception& e) {
48621       {
48622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48623       };
48624     } catch (...) {
48625       {
48626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48627       };
48628     }
48629   }
48630   jresult = (void *)result;
48631   return jresult;
48632 }
48633
48634
48635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
48636   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48637
48638   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48639   {
48640     try {
48641       delete arg1;
48642     } catch (std::out_of_range& e) {
48643       {
48644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48645       };
48646     } catch (std::exception& e) {
48647       {
48648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48649       };
48650     } catch (...) {
48651       {
48652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48653       };
48654     }
48655   }
48656 }
48657
48658
48659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
48660   unsigned int jresult ;
48661   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48662   bool result;
48663
48664   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48665   {
48666     try {
48667       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
48668     } catch (std::out_of_range& e) {
48669       {
48670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48671       };
48672     } catch (std::exception& e) {
48673       {
48674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48675       };
48676     } catch (...) {
48677       {
48678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48679       };
48680     }
48681   }
48682   jresult = result;
48683   return jresult;
48684 }
48685
48686
48687 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
48688   unsigned long jresult ;
48689   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48690   std::size_t result;
48691
48692   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48693   {
48694     try {
48695       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
48696     } catch (std::out_of_range& e) {
48697       {
48698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48699       };
48700     } catch (std::exception& e) {
48701       {
48702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48703       };
48704     } catch (...) {
48705       {
48706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48707       };
48708     }
48709   }
48710   jresult = (unsigned long)result;
48711   return jresult;
48712 }
48713
48714
48715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
48716   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48717   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
48718
48719   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48720   arg2 = (void (*)(Dali::Actor))jarg2;
48721   {
48722     try {
48723       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
48724     } catch (std::out_of_range& e) {
48725       {
48726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48727       };
48728     } catch (std::exception& e) {
48729       {
48730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48731       };
48732     } catch (...) {
48733       {
48734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48735       };
48736     }
48737   }
48738 }
48739
48740
48741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
48742   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48743   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
48744
48745   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48746   arg2 = (void (*)(Dali::Actor))jarg2;
48747   {
48748     try {
48749       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
48750     } catch (std::out_of_range& e) {
48751       {
48752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48753       };
48754     } catch (std::exception& e) {
48755       {
48756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48757       };
48758     } catch (...) {
48759       {
48760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48761       };
48762     }
48763   }
48764 }
48765
48766
48767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
48768   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48769   Dali::Actor arg2 ;
48770   Dali::Actor *argp2 ;
48771
48772   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48773   argp2 = (Dali::Actor *)jarg2;
48774   if (!argp2) {
48775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48776     return ;
48777   }
48778   arg2 = *argp2;
48779   {
48780     try {
48781       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
48782     } catch (std::out_of_range& e) {
48783       {
48784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48785       };
48786     } catch (std::exception& e) {
48787       {
48788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48789       };
48790     } catch (...) {
48791       {
48792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48793       };
48794     }
48795   }
48796 }
48797
48798
48799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
48800   void * jresult ;
48801   Dali::Signal< void (Dali::Actor) > *result = 0 ;
48802
48803   {
48804     try {
48805       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
48806     } catch (std::out_of_range& e) {
48807       {
48808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48809       };
48810     } catch (std::exception& e) {
48811       {
48812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48813       };
48814     } catch (...) {
48815       {
48816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48817       };
48818     }
48819   }
48820   jresult = (void *)result;
48821   return jresult;
48822 }
48823
48824
48825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
48826   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48827
48828   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48829   {
48830     try {
48831       delete arg1;
48832     } catch (std::out_of_range& e) {
48833       {
48834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48835       };
48836     } catch (std::exception& e) {
48837       {
48838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48839       };
48840     } catch (...) {
48841       {
48842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48843       };
48844     }
48845   }
48846 }
48847
48848
48849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
48850   unsigned int jresult ;
48851   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48852   bool result;
48853
48854   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48855   {
48856     try {
48857       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
48858     } catch (std::out_of_range& e) {
48859       {
48860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48861       };
48862     } catch (std::exception& e) {
48863       {
48864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48865       };
48866     } catch (...) {
48867       {
48868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48869       };
48870     }
48871   }
48872   jresult = result;
48873   return jresult;
48874 }
48875
48876
48877 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
48878   unsigned long jresult ;
48879   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48880   std::size_t result;
48881
48882   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48883   {
48884     try {
48885       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
48886     } catch (std::out_of_range& e) {
48887       {
48888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48889       };
48890     } catch (std::exception& e) {
48891       {
48892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48893       };
48894     } catch (...) {
48895       {
48896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48897       };
48898     }
48899   }
48900   jresult = (unsigned long)result;
48901   return jresult;
48902 }
48903
48904
48905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
48906   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48907   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
48908
48909   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48910   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
48911   {
48912     try {
48913       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48914     } catch (std::out_of_range& e) {
48915       {
48916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48917       };
48918     } catch (std::exception& e) {
48919       {
48920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48921       };
48922     } catch (...) {
48923       {
48924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48925       };
48926     }
48927   }
48928 }
48929
48930
48931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
48932   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48933   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
48934
48935   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48936   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
48937   {
48938     try {
48939       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48940     } catch (std::out_of_range& e) {
48941       {
48942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48943       };
48944     } catch (std::exception& e) {
48945       {
48946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48947       };
48948     } catch (...) {
48949       {
48950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48951       };
48952     }
48953   }
48954 }
48955
48956
48957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
48958   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48959   Dali::KeyEvent *arg2 = 0 ;
48960
48961   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48962   arg2 = (Dali::KeyEvent *)jarg2;
48963   if (!arg2) {
48964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
48965     return ;
48966   }
48967   {
48968     try {
48969       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
48970     } catch (std::out_of_range& e) {
48971       {
48972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48973       };
48974     } catch (std::exception& e) {
48975       {
48976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48977       };
48978     } catch (...) {
48979       {
48980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48981       };
48982     }
48983   }
48984 }
48985
48986
48987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
48988   void * jresult ;
48989   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
48990
48991   {
48992     try {
48993       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
48994     } catch (std::out_of_range& e) {
48995       {
48996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48997       };
48998     } catch (std::exception& e) {
48999       {
49000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49001       };
49002     } catch (...) {
49003       {
49004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49005       };
49006     }
49007   }
49008   jresult = (void *)result;
49009   return jresult;
49010 }
49011
49012
49013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
49014   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
49015
49016   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
49017   {
49018     try {
49019       delete arg1;
49020     } catch (std::out_of_range& e) {
49021       {
49022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49023       };
49024     } catch (std::exception& e) {
49025       {
49026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49027       };
49028     } catch (...) {
49029       {
49030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49031       };
49032     }
49033   }
49034 }
49035
49036
49037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
49038   unsigned int jresult ;
49039   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49040   bool result;
49041
49042   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49043   {
49044     try {
49045       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
49046     } catch (std::out_of_range& e) {
49047       {
49048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49049       };
49050     } catch (std::exception& e) {
49051       {
49052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49053       };
49054     } catch (...) {
49055       {
49056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49057       };
49058     }
49059   }
49060   jresult = result;
49061   return jresult;
49062 }
49063
49064
49065 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
49066   unsigned long jresult ;
49067   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49068   std::size_t result;
49069
49070   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49071   {
49072     try {
49073       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
49074     } catch (std::out_of_range& e) {
49075       {
49076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49077       };
49078     } catch (std::exception& e) {
49079       {
49080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49081       };
49082     } catch (...) {
49083       {
49084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49085       };
49086     }
49087   }
49088   jresult = (unsigned long)result;
49089   return jresult;
49090 }
49091
49092
49093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
49094   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49095   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
49096
49097   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49098   arg2 = (void (*)(Dali::TouchData const &))jarg2;
49099   {
49100     try {
49101       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49102     } catch (std::out_of_range& e) {
49103       {
49104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49105       };
49106     } catch (std::exception& e) {
49107       {
49108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49109       };
49110     } catch (...) {
49111       {
49112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49113       };
49114     }
49115   }
49116 }
49117
49118
49119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
49120   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49121   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
49122
49123   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49124   arg2 = (void (*)(Dali::TouchData const &))jarg2;
49125   {
49126     try {
49127       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49128     } catch (std::out_of_range& e) {
49129       {
49130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49131       };
49132     } catch (std::exception& e) {
49133       {
49134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49135       };
49136     } catch (...) {
49137       {
49138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49139       };
49140     }
49141   }
49142 }
49143
49144
49145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
49146   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49147   Dali::TouchData *arg2 = 0 ;
49148
49149   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49150   arg2 = (Dali::TouchData *)jarg2;
49151   if (!arg2) {
49152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
49153     return ;
49154   }
49155   {
49156     try {
49157       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
49158     } catch (std::out_of_range& e) {
49159       {
49160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49161       };
49162     } catch (std::exception& e) {
49163       {
49164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49165       };
49166     } catch (...) {
49167       {
49168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49169       };
49170     }
49171   }
49172 }
49173
49174
49175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
49176   void * jresult ;
49177   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
49178
49179   {
49180     try {
49181       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
49182     } catch (std::out_of_range& e) {
49183       {
49184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49185       };
49186     } catch (std::exception& e) {
49187       {
49188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49189       };
49190     } catch (...) {
49191       {
49192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49193       };
49194     }
49195   }
49196   jresult = (void *)result;
49197   return jresult;
49198 }
49199
49200
49201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
49202   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49203
49204   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49205   {
49206     try {
49207       delete arg1;
49208     } catch (std::out_of_range& e) {
49209       {
49210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49211       };
49212     } catch (std::exception& e) {
49213       {
49214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49215       };
49216     } catch (...) {
49217       {
49218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49219       };
49220     }
49221   }
49222 }
49223
49224
49225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
49226   unsigned int jresult ;
49227   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49228   bool result;
49229
49230   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49231   {
49232     try {
49233       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
49234     } catch (std::out_of_range& e) {
49235       {
49236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49237       };
49238     } catch (std::exception& e) {
49239       {
49240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49241       };
49242     } catch (...) {
49243       {
49244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49245       };
49246     }
49247   }
49248   jresult = result;
49249   return jresult;
49250 }
49251
49252
49253 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
49254   unsigned long jresult ;
49255   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49256   std::size_t result;
49257
49258   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49259   {
49260     try {
49261       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
49262     } catch (std::out_of_range& e) {
49263       {
49264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49265       };
49266     } catch (std::exception& e) {
49267       {
49268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49269       };
49270     } catch (...) {
49271       {
49272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49273       };
49274     }
49275   }
49276   jresult = (unsigned long)result;
49277   return jresult;
49278 }
49279
49280
49281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
49282   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49283   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
49284
49285   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49286   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
49287   {
49288     try {
49289       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49290     } catch (std::out_of_range& e) {
49291       {
49292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49293       };
49294     } catch (std::exception& e) {
49295       {
49296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49297       };
49298     } catch (...) {
49299       {
49300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49301       };
49302     }
49303   }
49304 }
49305
49306
49307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
49308   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49309   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
49310
49311   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49312   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
49313   {
49314     try {
49315       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49316     } catch (std::out_of_range& e) {
49317       {
49318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49319       };
49320     } catch (std::exception& e) {
49321       {
49322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49323       };
49324     } catch (...) {
49325       {
49326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49327       };
49328     }
49329   }
49330 }
49331
49332
49333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
49334   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49335   Dali::WheelEvent *arg2 = 0 ;
49336
49337   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49338   arg2 = (Dali::WheelEvent *)jarg2;
49339   if (!arg2) {
49340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
49341     return ;
49342   }
49343   {
49344     try {
49345       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
49346     } catch (std::out_of_range& e) {
49347       {
49348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49349       };
49350     } catch (std::exception& e) {
49351       {
49352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49353       };
49354     } catch (...) {
49355       {
49356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49357       };
49358     }
49359   }
49360 }
49361
49362
49363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
49364   void * jresult ;
49365   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
49366
49367   {
49368     try {
49369       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
49370     } catch (std::out_of_range& e) {
49371       {
49372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49373       };
49374     } catch (std::exception& e) {
49375       {
49376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49377       };
49378     } catch (...) {
49379       {
49380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49381       };
49382     }
49383   }
49384   jresult = (void *)result;
49385   return jresult;
49386 }
49387
49388
49389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
49390   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49391
49392   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49393   {
49394     try {
49395       delete arg1;
49396     } catch (std::out_of_range& e) {
49397       {
49398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49399       };
49400     } catch (std::exception& e) {
49401       {
49402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49403       };
49404     } catch (...) {
49405       {
49406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49407       };
49408     }
49409   }
49410 }
49411
49412
49413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
49414   void * jresult ;
49415   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
49416
49417   {
49418     try {
49419       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
49420     } catch (std::out_of_range& e) {
49421       {
49422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49423       };
49424     } catch (std::exception& e) {
49425       {
49426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49427       };
49428     } catch (...) {
49429       {
49430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49431       };
49432     }
49433   }
49434   jresult = (void *)result;
49435   return jresult;
49436 }
49437
49438
49439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
49440   void * jresult ;
49441   Dali::Radian arg1 ;
49442   Dali::Radian arg2 ;
49443   Dali::Radian *argp1 ;
49444   Dali::Radian *argp2 ;
49445   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
49446
49447   argp1 = (Dali::Radian *)jarg1;
49448   if (!argp1) {
49449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
49450     return 0;
49451   }
49452   arg1 = *argp1;
49453   argp2 = (Dali::Radian *)jarg2;
49454   if (!argp2) {
49455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
49456     return 0;
49457   }
49458   arg2 = *argp2;
49459   {
49460     try {
49461       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
49462     } catch (std::out_of_range& e) {
49463       {
49464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49465       };
49466     } catch (std::exception& e) {
49467       {
49468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49469       };
49470     } catch (...) {
49471       {
49472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49473       };
49474     }
49475   }
49476   jresult = (void *)result;
49477   return jresult;
49478 }
49479
49480
49481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
49482   void * jresult ;
49483   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
49484   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
49485
49486   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49487   if (!arg1) {
49488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
49489     return 0;
49490   }
49491   {
49492     try {
49493       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
49494     } catch (std::out_of_range& e) {
49495       {
49496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49497       };
49498     } catch (std::exception& e) {
49499       {
49500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49501       };
49502     } catch (...) {
49503       {
49504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49505       };
49506     }
49507   }
49508   jresult = (void *)result;
49509   return jresult;
49510 }
49511
49512
49513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
49514   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49515   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
49516
49517   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49518   arg2 = (Dali::Radian *)jarg2;
49519   if (arg1) (arg1)->first = *arg2;
49520 }
49521
49522
49523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
49524   void * jresult ;
49525   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49526   Dali::Radian *result = 0 ;
49527
49528   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49529   result = (Dali::Radian *)& ((arg1)->first);
49530   jresult = (void *)result;
49531   return jresult;
49532 }
49533
49534
49535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
49536   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49537   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
49538
49539   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49540   arg2 = (Dali::Radian *)jarg2;
49541   if (arg1) (arg1)->second = *arg2;
49542 }
49543
49544
49545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
49546   void * jresult ;
49547   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49548   Dali::Radian *result = 0 ;
49549
49550   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49551   result = (Dali::Radian *)& ((arg1)->second);
49552   jresult = (void *)result;
49553   return jresult;
49554 }
49555
49556
49557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
49558   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49559
49560   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49561   {
49562     try {
49563       delete arg1;
49564     } catch (std::out_of_range& e) {
49565       {
49566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49567       };
49568     } catch (std::exception& e) {
49569       {
49570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49571       };
49572     } catch (...) {
49573       {
49574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49575       };
49576     }
49577   }
49578 }
49579
49580
49581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
49582   unsigned int jresult ;
49583   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49584   bool result;
49585
49586   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49587   {
49588     try {
49589       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);
49590     } catch (std::out_of_range& e) {
49591       {
49592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49593       };
49594     } catch (std::exception& e) {
49595       {
49596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49597       };
49598     } catch (...) {
49599       {
49600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49601       };
49602     }
49603   }
49604   jresult = result;
49605   return jresult;
49606 }
49607
49608
49609 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49610   unsigned long jresult ;
49611   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49612   std::size_t result;
49613
49614   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49615   {
49616     try {
49617       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);
49618     } catch (std::out_of_range& e) {
49619       {
49620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49621       };
49622     } catch (std::exception& e) {
49623       {
49624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49625       };
49626     } catch (...) {
49627       {
49628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49629       };
49630     }
49631   }
49632   jresult = (unsigned long)result;
49633   return jresult;
49634 }
49635
49636
49637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49638   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49639   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
49640
49641   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49642   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
49643   {
49644     try {
49645       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49646     } catch (std::out_of_range& e) {
49647       {
49648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49649       };
49650     } catch (std::exception& e) {
49651       {
49652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49653       };
49654     } catch (...) {
49655       {
49656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49657       };
49658     }
49659   }
49660 }
49661
49662
49663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49664   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49665   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
49666
49667   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49668   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
49669   {
49670     try {
49671       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49672     } catch (std::out_of_range& e) {
49673       {
49674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49675       };
49676     } catch (std::exception& e) {
49677       {
49678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49679       };
49680     } catch (...) {
49681       {
49682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49683       };
49684     }
49685   }
49686 }
49687
49688
49689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49690   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49691   Dali::Actor arg2 ;
49692   Dali::PanGesture *arg3 = 0 ;
49693   Dali::Actor *argp2 ;
49694
49695   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49696   argp2 = (Dali::Actor *)jarg2;
49697   if (!argp2) {
49698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49699     return ;
49700   }
49701   arg2 = *argp2;
49702   arg3 = (Dali::PanGesture *)jarg3;
49703   if (!arg3) {
49704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
49705     return ;
49706   }
49707   {
49708     try {
49709       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
49710     } catch (std::out_of_range& e) {
49711       {
49712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49713       };
49714     } catch (std::exception& e) {
49715       {
49716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49717       };
49718     } catch (...) {
49719       {
49720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49721       };
49722     }
49723   }
49724 }
49725
49726
49727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
49728   void * jresult ;
49729   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
49730
49731   {
49732     try {
49733       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
49734     } catch (std::out_of_range& e) {
49735       {
49736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49737       };
49738     } catch (std::exception& e) {
49739       {
49740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49741       };
49742     } catch (...) {
49743       {
49744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49745       };
49746     }
49747   }
49748   jresult = (void *)result;
49749   return jresult;
49750 }
49751
49752
49753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
49754   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49755
49756   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49757   {
49758     try {
49759       delete arg1;
49760     } catch (std::out_of_range& e) {
49761       {
49762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49763       };
49764     } catch (std::exception& e) {
49765       {
49766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49767       };
49768     } catch (...) {
49769       {
49770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49771       };
49772     }
49773   }
49774 }
49775
49776
49777 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
49778   unsigned int jresult ;
49779   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49780   bool result;
49781
49782   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49783   {
49784     try {
49785       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);
49786     } catch (std::out_of_range& e) {
49787       {
49788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49789       };
49790     } catch (std::exception& e) {
49791       {
49792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49793       };
49794     } catch (...) {
49795       {
49796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49797       };
49798     }
49799   }
49800   jresult = result;
49801   return jresult;
49802 }
49803
49804
49805 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49806   unsigned long jresult ;
49807   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49808   std::size_t result;
49809
49810   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49811   {
49812     try {
49813       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);
49814     } catch (std::out_of_range& e) {
49815       {
49816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49817       };
49818     } catch (std::exception& e) {
49819       {
49820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49821       };
49822     } catch (...) {
49823       {
49824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49825       };
49826     }
49827   }
49828   jresult = (unsigned long)result;
49829   return jresult;
49830 }
49831
49832
49833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49834   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49835   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
49836
49837   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49838   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
49839   {
49840     try {
49841       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49842     } catch (std::out_of_range& e) {
49843       {
49844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49845       };
49846     } catch (std::exception& e) {
49847       {
49848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49849       };
49850     } catch (...) {
49851       {
49852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49853       };
49854     }
49855   }
49856 }
49857
49858
49859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49860   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49861   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
49862
49863   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49864   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
49865   {
49866     try {
49867       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49868     } catch (std::out_of_range& e) {
49869       {
49870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49871       };
49872     } catch (std::exception& e) {
49873       {
49874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49875       };
49876     } catch (...) {
49877       {
49878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49879       };
49880     }
49881   }
49882 }
49883
49884
49885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49886   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49887   Dali::Actor arg2 ;
49888   Dali::PinchGesture *arg3 = 0 ;
49889   Dali::Actor *argp2 ;
49890
49891   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49892   argp2 = (Dali::Actor *)jarg2;
49893   if (!argp2) {
49894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49895     return ;
49896   }
49897   arg2 = *argp2;
49898   arg3 = (Dali::PinchGesture *)jarg3;
49899   if (!arg3) {
49900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
49901     return ;
49902   }
49903   {
49904     try {
49905       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
49906     } catch (std::out_of_range& e) {
49907       {
49908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49909       };
49910     } catch (std::exception& e) {
49911       {
49912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49913       };
49914     } catch (...) {
49915       {
49916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49917       };
49918     }
49919   }
49920 }
49921
49922
49923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
49924   void * jresult ;
49925   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
49926
49927   {
49928     try {
49929       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
49930     } catch (std::out_of_range& e) {
49931       {
49932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49933       };
49934     } catch (std::exception& e) {
49935       {
49936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49937       };
49938     } catch (...) {
49939       {
49940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49941       };
49942     }
49943   }
49944   jresult = (void *)result;
49945   return jresult;
49946 }
49947
49948
49949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
49950   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49951
49952   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49953   {
49954     try {
49955       delete arg1;
49956     } catch (std::out_of_range& e) {
49957       {
49958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49959       };
49960     } catch (std::exception& e) {
49961       {
49962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49963       };
49964     } catch (...) {
49965       {
49966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49967       };
49968     }
49969   }
49970 }
49971
49972
49973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
49974   unsigned int jresult ;
49975   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
49976   bool result;
49977
49978   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
49979   {
49980     try {
49981       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);
49982     } catch (std::out_of_range& e) {
49983       {
49984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49985       };
49986     } catch (std::exception& e) {
49987       {
49988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49989       };
49990     } catch (...) {
49991       {
49992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49993       };
49994     }
49995   }
49996   jresult = result;
49997   return jresult;
49998 }
49999
50000
50001 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
50002   unsigned long jresult ;
50003   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50004   std::size_t result;
50005
50006   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50007   {
50008     try {
50009       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);
50010     } catch (std::out_of_range& e) {
50011       {
50012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50013       };
50014     } catch (std::exception& e) {
50015       {
50016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50017       };
50018     } catch (...) {
50019       {
50020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50021       };
50022     }
50023   }
50024   jresult = (unsigned long)result;
50025   return jresult;
50026 }
50027
50028
50029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
50030   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50031   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
50032
50033   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50034   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
50035   {
50036     try {
50037       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50038     } catch (std::out_of_range& e) {
50039       {
50040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50041       };
50042     } catch (std::exception& e) {
50043       {
50044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50045       };
50046     } catch (...) {
50047       {
50048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50049       };
50050     }
50051   }
50052 }
50053
50054
50055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
50056   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50057   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
50058
50059   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50060   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
50061   {
50062     try {
50063       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50064     } catch (std::out_of_range& e) {
50065       {
50066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50067       };
50068     } catch (std::exception& e) {
50069       {
50070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50071       };
50072     } catch (...) {
50073       {
50074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50075       };
50076     }
50077   }
50078 }
50079
50080
50081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50082   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50083   Dali::Actor arg2 ;
50084   Dali::TapGesture *arg3 = 0 ;
50085   Dali::Actor *argp2 ;
50086
50087   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50088   argp2 = (Dali::Actor *)jarg2;
50089   if (!argp2) {
50090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50091     return ;
50092   }
50093   arg2 = *argp2;
50094   arg3 = (Dali::TapGesture *)jarg3;
50095   if (!arg3) {
50096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
50097     return ;
50098   }
50099   {
50100     try {
50101       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
50102     } catch (std::out_of_range& e) {
50103       {
50104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50105       };
50106     } catch (std::exception& e) {
50107       {
50108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50109       };
50110     } catch (...) {
50111       {
50112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50113       };
50114     }
50115   }
50116 }
50117
50118
50119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
50120   void * jresult ;
50121   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
50122
50123   {
50124     try {
50125       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
50126     } catch (std::out_of_range& e) {
50127       {
50128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50129       };
50130     } catch (std::exception& e) {
50131       {
50132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50133       };
50134     } catch (...) {
50135       {
50136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50137       };
50138     }
50139   }
50140   jresult = (void *)result;
50141   return jresult;
50142 }
50143
50144
50145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
50146   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50147
50148   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50149   {
50150     try {
50151       delete arg1;
50152     } catch (std::out_of_range& e) {
50153       {
50154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50155       };
50156     } catch (std::exception& e) {
50157       {
50158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50159       };
50160     } catch (...) {
50161       {
50162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50163       };
50164     }
50165   }
50166 }
50167
50168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
50169   unsigned int jresult ;
50170   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50171   bool result;
50172
50173   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50174   {
50175     try {
50176       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
50177     } catch (std::out_of_range& e) {
50178       {
50179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50180       };
50181     } catch (std::exception& e) {
50182       {
50183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50184       };
50185     } catch (...) {
50186       {
50187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50188       };
50189     }
50190   }
50191   jresult = result;
50192   return jresult;
50193 }
50194
50195
50196 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
50197   unsigned long jresult ;
50198   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50199   std::size_t result;
50200
50201   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50202   {
50203     try {
50204       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
50205     } catch (std::out_of_range& e) {
50206       {
50207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50208       };
50209     } catch (std::exception& e) {
50210       {
50211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50212       };
50213     } catch (...) {
50214       {
50215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50216       };
50217     }
50218   }
50219   jresult = (unsigned long)result;
50220   return jresult;
50221 }
50222
50223
50224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
50225   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50226   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
50227
50228   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50229   arg2 = (void (*)(Dali::ResourceImage))jarg2;
50230   {
50231     try {
50232       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
50233     } catch (std::out_of_range& e) {
50234       {
50235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50236       };
50237     } catch (std::exception& e) {
50238       {
50239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50240       };
50241     } catch (...) {
50242       {
50243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50244       };
50245     }
50246   }
50247 }
50248
50249
50250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
50251   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50252   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
50253
50254   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50255   arg2 = (void (*)(Dali::ResourceImage))jarg2;
50256   {
50257     try {
50258       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
50259     } catch (std::out_of_range& e) {
50260       {
50261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50262       };
50263     } catch (std::exception& e) {
50264       {
50265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50266       };
50267     } catch (...) {
50268       {
50269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50270       };
50271     }
50272   }
50273 }
50274
50275
50276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
50277   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50278   Dali::ResourceImage arg2 ;
50279   Dali::ResourceImage *argp2 ;
50280
50281   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50282   argp2 = (Dali::ResourceImage *)jarg2;
50283   if (!argp2) {
50284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
50285     return ;
50286   }
50287   arg2 = *argp2;
50288   {
50289     try {
50290       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
50291     } catch (std::out_of_range& e) {
50292       {
50293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50294       };
50295     } catch (std::exception& e) {
50296       {
50297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50298       };
50299     } catch (...) {
50300       {
50301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50302       };
50303     }
50304   }
50305 }
50306
50307
50308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
50309   void * jresult ;
50310   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
50311
50312   {
50313     try {
50314       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
50315     } catch (std::out_of_range& e) {
50316       {
50317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50318       };
50319     } catch (std::exception& e) {
50320       {
50321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50322       };
50323     } catch (...) {
50324       {
50325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50326       };
50327     }
50328   }
50329   jresult = (void *)result;
50330   return jresult;
50331 }
50332
50333
50334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
50335   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50336
50337   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50338   {
50339     try {
50340       delete arg1;
50341     } catch (std::out_of_range& e) {
50342       {
50343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50344       };
50345     } catch (std::exception& e) {
50346       {
50347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50348       };
50349     } catch (...) {
50350       {
50351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50352       };
50353     }
50354   }
50355 }
50356
50357
50358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
50359   unsigned int jresult ;
50360   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50361   bool result;
50362
50363   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50364   {
50365     try {
50366       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *)arg1);
50367     } catch (std::out_of_range& e) {
50368       {
50369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50370       };
50371     } catch (std::exception& e) {
50372       {
50373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50374       };
50375     } catch (...) {
50376       {
50377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50378       };
50379     }
50380   }
50381   jresult = result;
50382   return jresult;
50383 }
50384
50385
50386 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
50387   unsigned long jresult ;
50388   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50389   std::size_t result;
50390
50391   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50392   {
50393     try {
50394       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *)arg1);
50395     } catch (std::out_of_range& e) {
50396       {
50397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50398       };
50399     } catch (std::exception& e) {
50400       {
50401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50402       };
50403     } catch (...) {
50404       {
50405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50406       };
50407     }
50408   }
50409   jresult = (unsigned long)result;
50410   return jresult;
50411 }
50412
50413
50414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
50415   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50416   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
50417
50418   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50419   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
50420   {
50421     try {
50422       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
50423     } catch (std::out_of_range& e) {
50424       {
50425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50426       };
50427     } catch (std::exception& e) {
50428       {
50429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50430       };
50431     } catch (...) {
50432       {
50433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50434       };
50435     }
50436   }
50437 }
50438
50439
50440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
50441   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50442   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
50443
50444   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50445   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
50446   {
50447     try {
50448       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
50449     } catch (std::out_of_range& e) {
50450       {
50451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50452       };
50453     } catch (std::exception& e) {
50454       {
50455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50456       };
50457     } catch (...) {
50458       {
50459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50460       };
50461     }
50462   }
50463 }
50464
50465
50466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
50467   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50468   Dali::Actor arg2 ;
50469   bool arg3 ;
50470   Dali::DevelActor::VisibilityChange::Type arg4 ;
50471   Dali::Actor *argp2 ;
50472
50473   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50474   argp2 = (Dali::Actor *)jarg2;
50475   if (!argp2) {
50476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50477     return ;
50478   }
50479   arg2 = *argp2;
50480   arg3 = jarg3 ? true : false;
50481   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
50482   {
50483     try {
50484       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
50485     } catch (std::out_of_range& e) {
50486       {
50487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50488       };
50489     } catch (std::exception& e) {
50490       {
50491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50492       };
50493     } catch (...) {
50494       {
50495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50496       };
50497     }
50498   }
50499 }
50500
50501
50502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
50503   void * jresult ;
50504   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
50505
50506   {
50507     try {
50508       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
50509     } catch (std::out_of_range& e) {
50510       {
50511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50512       };
50513     } catch (std::exception& e) {
50514       {
50515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50516       };
50517     } catch (...) {
50518       {
50519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50520       };
50521     }
50522   }
50523   jresult = (void *)result;
50524   return jresult;
50525 }
50526
50527
50528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
50529   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50530
50531   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50532   {
50533     try {
50534       delete arg1;
50535     } catch (std::out_of_range& e) {
50536       {
50537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50538       };
50539     } catch (std::exception& e) {
50540       {
50541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50542       };
50543     } catch (...) {
50544       {
50545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50546       };
50547     }
50548   }
50549 }
50550
50551
50552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
50553   void * jresult ;
50554   Dali::Timer *result = 0 ;
50555
50556   {
50557     try {
50558       result = (Dali::Timer *)new Dali::Timer();
50559     } catch (std::out_of_range& e) {
50560       {
50561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50562       };
50563     } catch (std::exception& e) {
50564       {
50565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50566       };
50567     } catch (...) {
50568       {
50569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50570       };
50571     }
50572   }
50573   jresult = (void *)result;
50574   return jresult;
50575 }
50576
50577
50578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
50579   void * jresult ;
50580   unsigned int arg1 ;
50581   Dali::Timer result;
50582
50583   arg1 = (unsigned int)jarg1;
50584   {
50585     try {
50586       result = Dali::Timer::New(arg1);
50587     } catch (std::out_of_range& e) {
50588       {
50589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50590       };
50591     } catch (std::exception& e) {
50592       {
50593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50594       };
50595     } catch (...) {
50596       {
50597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50598       };
50599     }
50600   }
50601   jresult = new Dali::Timer((const Dali::Timer &)result);
50602   return jresult;
50603 }
50604
50605
50606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
50607   void * jresult ;
50608   Dali::Timer *arg1 = 0 ;
50609   Dali::Timer *result = 0 ;
50610
50611   arg1 = (Dali::Timer *)jarg1;
50612   if (!arg1) {
50613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
50614     return 0;
50615   }
50616   {
50617     try {
50618       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
50619     } catch (std::out_of_range& e) {
50620       {
50621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50622       };
50623     } catch (std::exception& e) {
50624       {
50625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50626       };
50627     } catch (...) {
50628       {
50629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50630       };
50631     }
50632   }
50633   jresult = (void *)result;
50634   return jresult;
50635 }
50636
50637
50638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
50639   void * jresult ;
50640   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50641   Dali::Timer *arg2 = 0 ;
50642   Dali::Timer *result = 0 ;
50643
50644   arg1 = (Dali::Timer *)jarg1;
50645   arg2 = (Dali::Timer *)jarg2;
50646   if (!arg2) {
50647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
50648     return 0;
50649   }
50650   {
50651     try {
50652       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
50653     } catch (std::out_of_range& e) {
50654       {
50655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50656       };
50657     } catch (std::exception& e) {
50658       {
50659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50660       };
50661     } catch (...) {
50662       {
50663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50664       };
50665     }
50666   }
50667   jresult = (void *)result;
50668   return jresult;
50669 }
50670
50671
50672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
50673   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50674
50675   arg1 = (Dali::Timer *)jarg1;
50676   {
50677     try {
50678       delete arg1;
50679     } catch (std::out_of_range& e) {
50680       {
50681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50682       };
50683     } catch (std::exception& e) {
50684       {
50685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50686       };
50687     } catch (...) {
50688       {
50689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50690       };
50691     }
50692   }
50693 }
50694
50695
50696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
50697   void * jresult ;
50698   Dali::BaseHandle arg1 ;
50699   Dali::BaseHandle *argp1 ;
50700   Dali::Timer result;
50701
50702   argp1 = (Dali::BaseHandle *)jarg1;
50703   if (!argp1) {
50704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50705     return 0;
50706   }
50707   arg1 = *argp1;
50708   {
50709     try {
50710       result = Dali::Timer::DownCast(arg1);
50711     } catch (std::out_of_range& e) {
50712       {
50713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50714       };
50715     } catch (std::exception& e) {
50716       {
50717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50718       };
50719     } catch (...) {
50720       {
50721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50722       };
50723     }
50724   }
50725   jresult = new Dali::Timer((const Dali::Timer &)result);
50726   return jresult;
50727 }
50728
50729
50730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
50731   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50732
50733   arg1 = (Dali::Timer *)jarg1;
50734   {
50735     try {
50736       (arg1)->Start();
50737     } catch (std::out_of_range& e) {
50738       {
50739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50740       };
50741     } catch (std::exception& e) {
50742       {
50743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50744       };
50745     } catch (...) {
50746       {
50747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50748       };
50749     }
50750   }
50751 }
50752
50753
50754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
50755   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50756
50757   arg1 = (Dali::Timer *)jarg1;
50758   {
50759     try {
50760       (arg1)->Stop();
50761     } catch (std::out_of_range& e) {
50762       {
50763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50764       };
50765     } catch (std::exception& e) {
50766       {
50767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50768       };
50769     } catch (...) {
50770       {
50771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50772       };
50773     }
50774   }
50775 }
50776
50777
50778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
50779   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50780   unsigned int arg2 ;
50781
50782   arg1 = (Dali::Timer *)jarg1;
50783   arg2 = (unsigned int)jarg2;
50784   {
50785     try {
50786       (arg1)->SetInterval(arg2);
50787     } catch (std::out_of_range& e) {
50788       {
50789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50790       };
50791     } catch (std::exception& e) {
50792       {
50793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50794       };
50795     } catch (...) {
50796       {
50797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50798       };
50799     }
50800   }
50801 }
50802
50803
50804 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
50805   unsigned int jresult ;
50806   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50807   unsigned int result;
50808
50809   arg1 = (Dali::Timer *)jarg1;
50810   {
50811     try {
50812       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
50813     } catch (std::out_of_range& e) {
50814       {
50815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50816       };
50817     } catch (std::exception& e) {
50818       {
50819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50820       };
50821     } catch (...) {
50822       {
50823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50824       };
50825     }
50826   }
50827   jresult = result;
50828   return jresult;
50829 }
50830
50831
50832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
50833   unsigned int jresult ;
50834   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50835   bool result;
50836
50837   arg1 = (Dali::Timer *)jarg1;
50838   {
50839     try {
50840       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
50841     } catch (std::out_of_range& e) {
50842       {
50843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50844       };
50845     } catch (std::exception& e) {
50846       {
50847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50848       };
50849     } catch (...) {
50850       {
50851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50852       };
50853     }
50854   }
50855   jresult = result;
50856   return jresult;
50857 }
50858
50859
50860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
50861   void * jresult ;
50862   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50863   Dali::Timer::TimerSignalType *result = 0 ;
50864
50865   arg1 = (Dali::Timer *)jarg1;
50866   {
50867     try {
50868       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
50869     } catch (std::out_of_range& e) {
50870       {
50871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50872       };
50873     } catch (std::exception& e) {
50874       {
50875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50876       };
50877     } catch (...) {
50878       {
50879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50880       };
50881     }
50882   }
50883   jresult = (void *)result;
50884   return jresult;
50885 }
50886
50887
50888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
50889   void * jresult ;
50890   Dali::DragAndDropDetector *result = 0 ;
50891
50892   {
50893     try {
50894       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
50895     } catch (std::out_of_range& e) {
50896       {
50897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50898       };
50899     } catch (std::exception& e) {
50900       {
50901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50902       };
50903     } catch (...) {
50904       {
50905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50906       };
50907     }
50908   }
50909   jresult = (void *)result;
50910   return jresult;
50911 }
50912
50913
50914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
50915   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50916
50917   arg1 = (Dali::DragAndDropDetector *)jarg1;
50918   {
50919     try {
50920       delete arg1;
50921     } catch (std::out_of_range& e) {
50922       {
50923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50924       };
50925     } catch (std::exception& e) {
50926       {
50927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50928       };
50929     } catch (...) {
50930       {
50931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50932       };
50933     }
50934   }
50935 }
50936
50937
50938 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
50939   char * jresult ;
50940   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50941   std::string *result = 0 ;
50942
50943   arg1 = (Dali::DragAndDropDetector *)jarg1;
50944   {
50945     try {
50946       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
50947     } catch (std::out_of_range& e) {
50948       {
50949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50950       };
50951     } catch (std::exception& e) {
50952       {
50953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50954       };
50955     } catch (...) {
50956       {
50957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50958       };
50959     }
50960   }
50961   jresult = SWIG_csharp_string_callback(result->c_str());
50962   return jresult;
50963 }
50964
50965
50966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
50967   void * jresult ;
50968   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50969   Dali::Vector2 result;
50970
50971   arg1 = (Dali::DragAndDropDetector *)jarg1;
50972   {
50973     try {
50974       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
50975     } catch (std::out_of_range& e) {
50976       {
50977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50978       };
50979     } catch (std::exception& e) {
50980       {
50981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50982       };
50983     } catch (...) {
50984       {
50985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50986       };
50987     }
50988   }
50989   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
50990   return jresult;
50991 }
50992
50993
50994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
50995   void * jresult ;
50996   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50997   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
50998
50999   arg1 = (Dali::DragAndDropDetector *)jarg1;
51000   {
51001     try {
51002       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
51003     } catch (std::out_of_range& e) {
51004       {
51005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51006       };
51007     } catch (std::exception& e) {
51008       {
51009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51010       };
51011     } catch (...) {
51012       {
51013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51014       };
51015     }
51016   }
51017   jresult = (void *)result;
51018   return jresult;
51019 }
51020
51021
51022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
51023   void * jresult ;
51024   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51025   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51026
51027   arg1 = (Dali::DragAndDropDetector *)jarg1;
51028   {
51029     try {
51030       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
51031     } catch (std::out_of_range& e) {
51032       {
51033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51034       };
51035     } catch (std::exception& e) {
51036       {
51037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51038       };
51039     } catch (...) {
51040       {
51041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51042       };
51043     }
51044   }
51045   jresult = (void *)result;
51046   return jresult;
51047 }
51048
51049
51050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
51051   void * jresult ;
51052   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51053   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51054
51055   arg1 = (Dali::DragAndDropDetector *)jarg1;
51056   {
51057     try {
51058       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
51059     } catch (std::out_of_range& e) {
51060       {
51061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51062       };
51063     } catch (std::exception& e) {
51064       {
51065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51066       };
51067     } catch (...) {
51068       {
51069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51070       };
51071     }
51072   }
51073   jresult = (void *)result;
51074   return jresult;
51075 }
51076
51077
51078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
51079   void * jresult ;
51080   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51081   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51082
51083   arg1 = (Dali::DragAndDropDetector *)jarg1;
51084   {
51085     try {
51086       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
51087     } catch (std::out_of_range& e) {
51088       {
51089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51090       };
51091     } catch (std::exception& e) {
51092       {
51093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51094       };
51095     } catch (...) {
51096       {
51097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51098       };
51099     }
51100   }
51101   jresult = (void *)result;
51102   return jresult;
51103 }
51104
51105
51106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
51107   void * jresult ;
51108   Dali::ApplicationExtensions *result = 0 ;
51109
51110   {
51111     try {
51112       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
51113     } catch (std::out_of_range& e) {
51114       {
51115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51116       };
51117     } catch (std::exception& e) {
51118       {
51119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51120       };
51121     } catch (...) {
51122       {
51123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51124       };
51125     }
51126   }
51127   jresult = (void *)result;
51128   return jresult;
51129 }
51130
51131
51132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
51133   void * jresult ;
51134   Dali::Application *arg1 = (Dali::Application *) 0 ;
51135   Dali::ApplicationExtensions *result = 0 ;
51136
51137   arg1 = (Dali::Application *)jarg1;
51138   {
51139     try {
51140       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
51141     } catch (std::out_of_range& e) {
51142       {
51143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51144       };
51145     } catch (std::exception& e) {
51146       {
51147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51148       };
51149     } catch (...) {
51150       {
51151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51152       };
51153     }
51154   }
51155   jresult = (void *)result;
51156   return jresult;
51157 }
51158
51159
51160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
51161   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51162
51163   arg1 = (Dali::ApplicationExtensions *)jarg1;
51164   {
51165     try {
51166       delete arg1;
51167     } catch (std::out_of_range& e) {
51168       {
51169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51170       };
51171     } catch (std::exception& e) {
51172       {
51173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51174       };
51175     } catch (...) {
51176       {
51177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51178       };
51179     }
51180   }
51181 }
51182
51183
51184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
51185   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51186
51187   arg1 = (Dali::ApplicationExtensions *)jarg1;
51188   {
51189     try {
51190       (arg1)->Init();
51191     } catch (std::out_of_range& e) {
51192       {
51193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51194       };
51195     } catch (std::exception& e) {
51196       {
51197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51198       };
51199     } catch (...) {
51200       {
51201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51202       };
51203     }
51204   }
51205 }
51206
51207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
51208   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51209
51210   arg1 = (Dali::ApplicationExtensions *)jarg1;
51211   {
51212     try {
51213       (arg1)->Start();
51214     } catch (std::out_of_range& e) {
51215       {
51216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51217       };
51218     } catch (std::exception& e) {
51219       {
51220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51221       };
51222     } catch (...) {
51223       {
51224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51225       };
51226     }
51227   }
51228 }
51229
51230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
51231   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51232
51233   arg1 = (Dali::ApplicationExtensions *)jarg1;
51234   {
51235     try {
51236       (arg1)->Terminate();
51237     } catch (std::out_of_range& e) {
51238       {
51239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51240       };
51241     } catch (std::exception& e) {
51242       {
51243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51244       };
51245     } catch (...) {
51246       {
51247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51248       };
51249     }
51250   }
51251 }
51252
51253
51254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
51255   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51256
51257   arg1 = (Dali::ApplicationExtensions *)jarg1;
51258   {
51259     try {
51260       (arg1)->Pause();
51261     } catch (std::out_of_range& e) {
51262       {
51263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51264       };
51265     } catch (std::exception& e) {
51266       {
51267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51268       };
51269     } catch (...) {
51270       {
51271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51272       };
51273     }
51274   }
51275 }
51276
51277
51278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
51279   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51280
51281   arg1 = (Dali::ApplicationExtensions *)jarg1;
51282   {
51283     try {
51284       (arg1)->Resume();
51285     } catch (std::out_of_range& e) {
51286       {
51287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51288       };
51289     } catch (std::exception& e) {
51290       {
51291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51292       };
51293     } catch (...) {
51294       {
51295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51296       };
51297     }
51298   }
51299 }
51300
51301
51302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
51303   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51304
51305   arg1 = (Dali::ApplicationExtensions *)jarg1;
51306   {
51307     try {
51308       (arg1)->LanguageChange();
51309     } catch (std::out_of_range& e) {
51310       {
51311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51312       };
51313     } catch (std::exception& e) {
51314       {
51315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51316       };
51317     } catch (...) {
51318       {
51319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51320       };
51321     }
51322   }
51323 }
51324
51325
51326
51327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
51328   unsigned int jresult ;
51329   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51330   bool result;
51331
51332   arg1 = (Dali::Signal< bool () > *)jarg1;
51333   {
51334     try {
51335       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
51336     } catch (std::out_of_range& e) {
51337       {
51338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51339       };
51340     } catch (std::exception& e) {
51341       {
51342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51343       };
51344     } catch (...) {
51345       {
51346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51347       };
51348     }
51349   }
51350   jresult = result;
51351   return jresult;
51352 }
51353
51354
51355 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
51356   unsigned long jresult ;
51357   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51358   std::size_t result;
51359
51360   arg1 = (Dali::Signal< bool () > *)jarg1;
51361   {
51362     try {
51363       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
51364     } catch (std::out_of_range& e) {
51365       {
51366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51367       };
51368     } catch (std::exception& e) {
51369       {
51370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51371       };
51372     } catch (...) {
51373       {
51374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51375       };
51376     }
51377   }
51378   jresult = (unsigned long)result;
51379   return jresult;
51380 }
51381
51382
51383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
51384   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51385   bool (*arg2)() = (bool (*)()) 0 ;
51386
51387   arg1 = (Dali::Signal< bool () > *)jarg1;
51388   arg2 = (bool (*)())jarg2;
51389   {
51390     try {
51391       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
51392     } catch (std::out_of_range& e) {
51393       {
51394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51395       };
51396     } catch (std::exception& e) {
51397       {
51398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51399       };
51400     } catch (...) {
51401       {
51402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51403       };
51404     }
51405   }
51406 }
51407
51408
51409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
51410   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51411   bool (*arg2)() = (bool (*)()) 0 ;
51412
51413   arg1 = (Dali::Signal< bool () > *)jarg1;
51414   arg2 = (bool (*)())jarg2;
51415   {
51416     try {
51417       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
51418     } catch (std::out_of_range& e) {
51419       {
51420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51421       };
51422     } catch (std::exception& e) {
51423       {
51424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51425       };
51426     } catch (...) {
51427       {
51428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51429       };
51430     }
51431   }
51432 }
51433
51434
51435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
51436   unsigned int jresult ;
51437   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51438   bool result;
51439
51440   arg1 = (Dali::Signal< bool () > *)jarg1;
51441   {
51442     try {
51443       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
51444     } catch (std::out_of_range& e) {
51445       {
51446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51447       };
51448     } catch (std::exception& e) {
51449       {
51450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51451       };
51452     } catch (...) {
51453       {
51454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51455       };
51456     }
51457   }
51458   jresult = result;
51459   return jresult;
51460 }
51461
51462
51463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
51464   void * jresult ;
51465   Dali::Signal< bool () > *result = 0 ;
51466
51467   {
51468     try {
51469       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
51470     } catch (std::out_of_range& e) {
51471       {
51472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51473       };
51474     } catch (std::exception& e) {
51475       {
51476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51477       };
51478     } catch (...) {
51479       {
51480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51481       };
51482     }
51483   }
51484   jresult = (void *)result;
51485   return jresult;
51486 }
51487
51488
51489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
51490   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51491
51492   arg1 = (Dali::Signal< bool () > *)jarg1;
51493   {
51494     try {
51495       delete arg1;
51496     } catch (std::out_of_range& e) {
51497       {
51498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51499       };
51500     } catch (std::exception& e) {
51501       {
51502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51503       };
51504     } catch (...) {
51505       {
51506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51507       };
51508     }
51509   }
51510 }
51511
51512
51513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
51514   int jresult ;
51515   int result;
51516
51517   {
51518     try {
51519       result = (int)Dali::Toolkit::Visual::Property::TYPE;
51520     } catch (std::out_of_range& e) {
51521       {
51522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51523       };
51524     } catch (std::exception& e) {
51525       {
51526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51527       };
51528     } catch (...) {
51529       {
51530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51531       };
51532     }
51533   }
51534   jresult = (int)result;
51535   return jresult;
51536 }
51537
51538
51539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
51540   int jresult ;
51541   int result;
51542
51543   {
51544     try {
51545       result = (int)Dali::Toolkit::Visual::Property::SHADER;
51546     } catch (std::out_of_range& e) {
51547       {
51548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51549       };
51550     } catch (std::exception& e) {
51551       {
51552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51553       };
51554     } catch (...) {
51555       {
51556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51557       };
51558     }
51559   }
51560   jresult = (int)result;
51561   return jresult;
51562 }
51563
51564
51565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
51566   int jresult ;
51567   int result;
51568
51569   {
51570     try {
51571       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
51572     } catch (std::out_of_range& e) {
51573       {
51574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51575       };
51576     } catch (std::exception& e) {
51577       {
51578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51579       };
51580     } catch (...) {
51581       {
51582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51583       };
51584     }
51585   }
51586   jresult = (int)result;
51587   return jresult;
51588 }
51589
51590
51591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
51592   int jresult ;
51593   int result;
51594
51595   {
51596     try {
51597       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
51598     } catch (std::out_of_range& e) {
51599       {
51600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51601       };
51602     } catch (std::exception& e) {
51603       {
51604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51605       };
51606     } catch (...) {
51607       {
51608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51609       };
51610     }
51611   }
51612   jresult = (int)result;
51613   return jresult;
51614 }
51615
51616
51617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
51618   int jresult ;
51619   int result;
51620
51621   {
51622     try {
51623       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
51624     } catch (std::out_of_range& e) {
51625       {
51626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51627       };
51628     } catch (std::exception& e) {
51629       {
51630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51631       };
51632     } catch (...) {
51633       {
51634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51635       };
51636     }
51637   }
51638   jresult = (int)result;
51639   return jresult;
51640 }
51641
51642
51643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
51644   int jresult ;
51645   int result;
51646
51647   {
51648     try {
51649       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
51650     } catch (std::out_of_range& e) {
51651       {
51652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51653       };
51654     } catch (std::exception& e) {
51655       {
51656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51657       };
51658     } catch (...) {
51659       {
51660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51661       };
51662     }
51663   }
51664   jresult = (int)result;
51665   return jresult;
51666 }
51667
51668
51669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
51670   int jresult ;
51671   int result;
51672
51673   {
51674     try {
51675       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
51676     } catch (std::out_of_range& e) {
51677       {
51678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51679       };
51680     } catch (std::exception& e) {
51681       {
51682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51683       };
51684     } catch (...) {
51685       {
51686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51687       };
51688     }
51689   }
51690   jresult = (int)result;
51691   return jresult;
51692 }
51693
51694
51695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
51696   int jresult ;
51697   int result;
51698
51699   {
51700     try {
51701       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
51702     } catch (std::out_of_range& e) {
51703       {
51704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51705       };
51706     } catch (std::exception& e) {
51707       {
51708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51709       };
51710     } catch (...) {
51711       {
51712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51713       };
51714     }
51715   }
51716   jresult = (int)result;
51717   return jresult;
51718 }
51719
51720
51721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
51722   int jresult ;
51723   int result;
51724
51725   {
51726     try {
51727       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
51728     } catch (std::out_of_range& e) {
51729       {
51730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51731       };
51732     } catch (std::exception& e) {
51733       {
51734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51735       };
51736     } catch (...) {
51737       {
51738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51739       };
51740     }
51741   }
51742   jresult = (int)result;
51743   return jresult;
51744 }
51745
51746
51747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
51748   int jresult ;
51749   int result;
51750
51751   {
51752     try {
51753       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
51754     } catch (std::out_of_range& e) {
51755       {
51756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51757       };
51758     } catch (std::exception& e) {
51759       {
51760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51761       };
51762     } catch (...) {
51763       {
51764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51765       };
51766     }
51767   }
51768   jresult = (int)result;
51769   return jresult;
51770 }
51771
51772
51773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
51774   int jresult ;
51775   int result;
51776
51777   {
51778     try {
51779       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
51780     } catch (std::out_of_range& e) {
51781       {
51782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51783       };
51784     } catch (std::exception& e) {
51785       {
51786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51787       };
51788     } catch (...) {
51789       {
51790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51791       };
51792     }
51793   }
51794   jresult = (int)result;
51795   return jresult;
51796 }
51797
51798
51799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
51800   int jresult ;
51801   int result;
51802
51803   {
51804     try {
51805       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
51806     } catch (std::out_of_range& e) {
51807       {
51808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51809       };
51810     } catch (std::exception& e) {
51811       {
51812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51813       };
51814     } catch (...) {
51815       {
51816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51817       };
51818     }
51819   }
51820   jresult = (int)result;
51821   return jresult;
51822 }
51823
51824
51825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
51826   int jresult ;
51827   int result;
51828
51829   {
51830     try {
51831       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
51832     } catch (std::out_of_range& e) {
51833       {
51834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51835       };
51836     } catch (std::exception& e) {
51837       {
51838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51839       };
51840     } catch (...) {
51841       {
51842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51843       };
51844     }
51845   }
51846   jresult = (int)result;
51847   return jresult;
51848 }
51849
51850
51851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
51852   int jresult ;
51853   int result;
51854
51855   {
51856     try {
51857       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
51858     } catch (std::out_of_range& e) {
51859       {
51860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51861       };
51862     } catch (std::exception& e) {
51863       {
51864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51865       };
51866     } catch (...) {
51867       {
51868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51869       };
51870     }
51871   }
51872   jresult = (int)result;
51873   return jresult;
51874 }
51875
51876
51877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
51878   int jresult ;
51879   int result;
51880
51881   {
51882     try {
51883       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
51884     } catch (std::out_of_range& e) {
51885       {
51886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51887       };
51888     } catch (std::exception& e) {
51889       {
51890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51891       };
51892     } catch (...) {
51893       {
51894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51895       };
51896     }
51897   }
51898   jresult = (int)result;
51899   return jresult;
51900 }
51901
51902
51903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
51904   int jresult ;
51905   int result;
51906
51907   {
51908     try {
51909       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
51910     } catch (std::out_of_range& e) {
51911       {
51912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51913       };
51914     } catch (std::exception& e) {
51915       {
51916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51917       };
51918     } catch (...) {
51919       {
51920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51921       };
51922     }
51923   }
51924   jresult = (int)result;
51925   return jresult;
51926 }
51927
51928
51929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
51930   int jresult ;
51931   int result;
51932
51933   {
51934     try {
51935       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
51936     } catch (std::out_of_range& e) {
51937       {
51938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51939       };
51940     } catch (std::exception& e) {
51941       {
51942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51943       };
51944     } catch (...) {
51945       {
51946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51947       };
51948     }
51949   }
51950   jresult = (int)result;
51951   return jresult;
51952 }
51953
51954
51955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
51956   int jresult ;
51957   int result;
51958
51959   {
51960     try {
51961       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
51962     } catch (std::out_of_range& e) {
51963       {
51964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51965       };
51966     } catch (std::exception& e) {
51967       {
51968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51969       };
51970     } catch (...) {
51971       {
51972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51973       };
51974     }
51975   }
51976   jresult = (int)result;
51977   return jresult;
51978 }
51979
51980
51981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
51982   int jresult ;
51983   int result;
51984
51985   {
51986     try {
51987       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
51988     } catch (std::out_of_range& e) {
51989       {
51990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51991       };
51992     } catch (std::exception& e) {
51993       {
51994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51995       };
51996     } catch (...) {
51997       {
51998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51999       };
52000     }
52001   }
52002   jresult = (int)result;
52003   return jresult;
52004 }
52005
52006
52007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
52008   int jresult ;
52009   int result;
52010
52011   {
52012     try {
52013       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
52014     } catch (std::out_of_range& e) {
52015       {
52016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52017       };
52018     } catch (std::exception& e) {
52019       {
52020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52021       };
52022     } catch (...) {
52023       {
52024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52025       };
52026     }
52027   }
52028   jresult = (int)result;
52029   return jresult;
52030 }
52031
52032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
52033   int jresult ;
52034   int result;
52035
52036   {
52037     try {
52038       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
52039     } catch (std::out_of_range& e) {
52040       {
52041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52042       };
52043     } catch (std::exception& e) {
52044       {
52045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52046       };
52047     } catch (...) {
52048       {
52049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52050       };
52051     }
52052   }
52053   jresult = (int)result;
52054   return jresult;
52055 }
52056
52057
52058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
52059   int jresult ;
52060   int result;
52061   {
52062     try
52063     {
52064       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
52065     } catch (std::out_of_range& e) {
52066       {
52067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52068       };
52069     } catch (std::exception& e) {
52070       {
52071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52072       };
52073     } catch (...) {
52074       {
52075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52076       };
52077     }
52078   }
52079   jresult = (int)result;
52080   return jresult;
52081 }
52082
52083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
52084   int jresult ;
52085   int result;
52086   {
52087     try
52088     {
52089       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
52090     } catch (std::out_of_range& e) {
52091       {
52092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52093       };
52094     } catch (std::exception& e) {
52095       {
52096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52097       };
52098     } catch (...) {
52099       {
52100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52101       };
52102     }
52103   }
52104   jresult = (int)result;
52105   return jresult;
52106 }
52107
52108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
52109   int jresult ;
52110   int result;
52111   {
52112     try
52113     {
52114       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
52115     } catch (std::out_of_range& e) {
52116       {
52117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52118       };
52119     } catch (std::exception& e) {
52120       {
52121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52122       };
52123     } catch (...) {
52124       {
52125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52126       };
52127     }
52128   }
52129   jresult = (int)result;
52130   return jresult;
52131 }
52132
52133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
52134   int jresult ;
52135   int result;
52136   {
52137     try
52138     {
52139       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
52140     } catch (std::out_of_range& e) {
52141       {
52142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52143       };
52144     } catch (std::exception& e) {
52145       {
52146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52147       };
52148     } catch (...) {
52149       {
52150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52151       };
52152     }
52153   }
52154   jresult = (int)result;
52155   return jresult;
52156 }
52157
52158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
52159   int jresult ;
52160   int result;
52161   {
52162     try
52163     {
52164       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
52165     } catch (std::out_of_range& e) {
52166       {
52167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52168       };
52169     } catch (std::exception& e) {
52170       {
52171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52172       };
52173     } catch (...) {
52174       {
52175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52176       };
52177     }
52178   }
52179   jresult = (int)result;
52180   return jresult;
52181 }
52182
52183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
52184   int jresult ;
52185   int result;
52186
52187   {
52188     try {
52189       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
52190     } catch (std::out_of_range& e) {
52191       {
52192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52193       };
52194     } catch (std::exception& e) {
52195       {
52196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52197       };
52198     } catch (...) {
52199       {
52200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52201       };
52202     }
52203   }
52204   jresult = (int)result;
52205   return jresult;
52206 }
52207
52208
52209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
52210   int jresult ;
52211   int result;
52212
52213   {
52214     try {
52215       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
52216     } catch (std::out_of_range& e) {
52217       {
52218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52219       };
52220     } catch (std::exception& e) {
52221       {
52222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52223       };
52224     } catch (...) {
52225       {
52226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52227       };
52228     }
52229   }
52230   jresult = (int)result;
52231   return jresult;
52232 }
52233
52234
52235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
52236   int jresult ;
52237   int result;
52238
52239   {
52240     try {
52241       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
52242     } catch (std::out_of_range& e) {
52243       {
52244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52245       };
52246     } catch (std::exception& e) {
52247       {
52248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52249       };
52250     } catch (...) {
52251       {
52252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52253       };
52254     }
52255   }
52256   jresult = (int)result;
52257   return jresult;
52258 }
52259
52260
52261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
52262   int jresult ;
52263   int result;
52264
52265   {
52266     try {
52267       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
52268     } catch (std::out_of_range& e) {
52269       {
52270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52271       };
52272     } catch (std::exception& e) {
52273       {
52274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52275       };
52276     } catch (...) {
52277       {
52278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52279       };
52280     }
52281   }
52282   jresult = (int)result;
52283   return jresult;
52284 }
52285
52286
52287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
52288   int jresult ;
52289   int result;
52290
52291   {
52292     try {
52293       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
52294     } catch (std::out_of_range& e) {
52295       {
52296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52297       };
52298     } catch (std::exception& e) {
52299       {
52300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52301       };
52302     } catch (...) {
52303       {
52304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52305       };
52306     }
52307   }
52308   jresult = (int)result;
52309   return jresult;
52310 }
52311
52312
52313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
52314   int jresult ;
52315   int result;
52316
52317   {
52318     try {
52319       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
52320     } catch (std::out_of_range& e) {
52321       {
52322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52323       };
52324     } catch (std::exception& e) {
52325       {
52326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52327       };
52328     } catch (...) {
52329       {
52330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52331       };
52332     }
52333   }
52334   jresult = (int)result;
52335   return jresult;
52336 }
52337
52338
52339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
52340   int jresult ;
52341   int result;
52342
52343   {
52344     try {
52345       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
52346     } catch (std::out_of_range& e) {
52347       {
52348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52349       };
52350     } catch (std::exception& e) {
52351       {
52352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52353       };
52354     } catch (...) {
52355       {
52356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52357       };
52358     }
52359   }
52360   jresult = (int)result;
52361   return jresult;
52362 }
52363
52364
52365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
52366   int jresult ;
52367   int result;
52368
52369   {
52370     try {
52371       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
52372     } catch (std::out_of_range& e) {
52373       {
52374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52375       };
52376     } catch (std::exception& e) {
52377       {
52378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52379       };
52380     } catch (...) {
52381       {
52382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52383       };
52384     }
52385   }
52386   jresult = (int)result;
52387   return jresult;
52388 }
52389
52390
52391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
52392   int jresult ;
52393   int result;
52394
52395   {
52396     try {
52397       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
52398     } catch (std::out_of_range& e) {
52399       {
52400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52401       };
52402     } catch (std::exception& e) {
52403       {
52404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52405       };
52406     } catch (...) {
52407       {
52408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52409       };
52410     }
52411   }
52412   jresult = (int)result;
52413   return jresult;
52414 }
52415
52416 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
52417   int jresult ;
52418   int result;
52419
52420   {
52421     try {
52422       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
52423     } catch (std::out_of_range& e) {
52424       {
52425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52426       };
52427     } catch (std::exception& e) {
52428       {
52429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52430       };
52431     } catch (...) {
52432       {
52433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52434       };
52435     }
52436   }
52437   jresult = (int)result;
52438   return jresult;
52439 }
52440
52441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
52442   int jresult ;
52443   int result;
52444
52445   {
52446     try {
52447       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
52448     } catch (std::out_of_range& e) {
52449       {
52450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52451       };
52452     } catch (std::exception& e) {
52453       {
52454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52455       };
52456     } catch (...) {
52457       {
52458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52459       };
52460     }
52461   }
52462   jresult = (int)result;
52463   return jresult;
52464 }
52465
52466
52467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
52468   int jresult ;
52469   int result;
52470
52471   {
52472     try {
52473       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
52474     } catch (std::out_of_range& e) {
52475       {
52476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52477       };
52478     } catch (std::exception& e) {
52479       {
52480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52481       };
52482     } catch (...) {
52483       {
52484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52485       };
52486     }
52487   }
52488   jresult = (int)result;
52489   return jresult;
52490 }
52491
52492
52493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
52494   int jresult ;
52495   int result;
52496
52497   {
52498     try {
52499       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
52500     } catch (std::out_of_range& e) {
52501       {
52502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52503       };
52504     } catch (std::exception& e) {
52505       {
52506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52507       };
52508     } catch (...) {
52509       {
52510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52511       };
52512     }
52513   }
52514   jresult = (int)result;
52515   return jresult;
52516 }
52517
52518
52519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
52520   int jresult ;
52521   int result;
52522
52523   {
52524     try {
52525       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
52526     } catch (std::out_of_range& e) {
52527       {
52528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52529       };
52530     } catch (std::exception& e) {
52531       {
52532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52533       };
52534     } catch (...) {
52535       {
52536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52537       };
52538     }
52539   }
52540   jresult = (int)result;
52541   return jresult;
52542 }
52543
52544
52545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
52546   int jresult ;
52547   int result;
52548
52549   {
52550     try {
52551       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
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 = (int)result;
52567   return jresult;
52568 }
52569
52570
52571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
52572   int jresult ;
52573   int result;
52574
52575   {
52576     try {
52577       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
52578     } catch (std::out_of_range& e) {
52579       {
52580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52581       };
52582     } catch (std::exception& e) {
52583       {
52584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52585       };
52586     } catch (...) {
52587       {
52588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52589       };
52590     }
52591   }
52592   jresult = (int)result;
52593   return jresult;
52594 }
52595
52596
52597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
52598   int jresult ;
52599   int result;
52600
52601   {
52602     try {
52603       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
52604     } catch (std::out_of_range& e) {
52605       {
52606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52607       };
52608     } catch (std::exception& e) {
52609       {
52610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52611       };
52612     } catch (...) {
52613       {
52614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52615       };
52616     }
52617   }
52618   jresult = (int)result;
52619   return jresult;
52620 }
52621
52622
52623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
52624   int jresult ;
52625   int result;
52626
52627   {
52628     try {
52629       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
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 = (int)result;
52645   return jresult;
52646 }
52647
52648
52649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
52650   int jresult ;
52651   int result;
52652
52653   {
52654     try {
52655       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
52656     } catch (std::out_of_range& e) {
52657       {
52658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52659       };
52660     } catch (std::exception& e) {
52661       {
52662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52663       };
52664     } catch (...) {
52665       {
52666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52667       };
52668     }
52669   }
52670   jresult = (int)result;
52671   return jresult;
52672 }
52673
52674
52675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
52676   int jresult ;
52677   int result;
52678
52679   {
52680     try {
52681       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
52682     } catch (std::out_of_range& e) {
52683       {
52684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52685       };
52686     } catch (std::exception& e) {
52687       {
52688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52689       };
52690     } catch (...) {
52691       {
52692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52693       };
52694     }
52695   }
52696   jresult = (int)result;
52697   return jresult;
52698 }
52699
52700
52701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
52702   int jresult ;
52703   int result;
52704
52705   {
52706     try {
52707       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
52708     } catch (std::out_of_range& e) {
52709       {
52710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52711       };
52712     } catch (std::exception& e) {
52713       {
52714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52715       };
52716     } catch (...) {
52717       {
52718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52719       };
52720     }
52721   }
52722   jresult = (int)result;
52723   return jresult;
52724 }
52725
52726
52727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
52728   int jresult ;
52729   int result;
52730
52731   {
52732     try {
52733       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
52734     } catch (std::out_of_range& e) {
52735       {
52736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52737       };
52738     } catch (std::exception& e) {
52739       {
52740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52741       };
52742     } catch (...) {
52743       {
52744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52745       };
52746     }
52747   }
52748   jresult = (int)result;
52749   return jresult;
52750 }
52751
52752
52753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
52754   int jresult ;
52755   int result;
52756
52757   {
52758     try {
52759       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
52760     } catch (std::out_of_range& e) {
52761       {
52762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52763       };
52764     } catch (std::exception& e) {
52765       {
52766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52767       };
52768     } catch (...) {
52769       {
52770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52771       };
52772     }
52773   }
52774   jresult = (int)result;
52775   return jresult;
52776 }
52777
52778
52779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
52780   int jresult ;
52781   int result;
52782
52783   {
52784     try {
52785       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
52786     } catch (std::out_of_range& e) {
52787       {
52788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52789       };
52790     } catch (std::exception& e) {
52791       {
52792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52793       };
52794     } catch (...) {
52795       {
52796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52797       };
52798     }
52799   }
52800   jresult = (int)result;
52801   return jresult;
52802 }
52803
52804
52805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
52806   int jresult ;
52807   int result;
52808
52809   {
52810     try {
52811       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
52812     } catch (std::out_of_range& e) {
52813       {
52814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52815       };
52816     } catch (std::exception& e) {
52817       {
52818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52819       };
52820     } catch (...) {
52821       {
52822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52823       };
52824     }
52825   }
52826   jresult = (int)result;
52827   return jresult;
52828 }
52829
52830
52831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
52832   int jresult ;
52833   int result;
52834
52835   {
52836     try {
52837       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
52838     } catch (std::out_of_range& e) {
52839       {
52840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52841       };
52842     } catch (std::exception& e) {
52843       {
52844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52845       };
52846     } catch (...) {
52847       {
52848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52849       };
52850     }
52851   }
52852   jresult = (int)result;
52853   return jresult;
52854 }
52855
52856
52857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
52858   int jresult ;
52859   int result;
52860
52861   {
52862     try {
52863       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
52864     } catch (std::out_of_range& e) {
52865       {
52866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52867       };
52868     } catch (std::exception& e) {
52869       {
52870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52871       };
52872     } catch (...) {
52873       {
52874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52875       };
52876     }
52877   }
52878   jresult = (int)result;
52879   return jresult;
52880 }
52881
52882
52883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
52884   int jresult ;
52885   int result;
52886
52887   {
52888     try {
52889       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
52890     } catch (std::out_of_range& e) {
52891       {
52892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52893       };
52894     } catch (std::exception& e) {
52895       {
52896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52897       };
52898     } catch (...) {
52899       {
52900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52901       };
52902     }
52903   }
52904   jresult = (int)result;
52905   return jresult;
52906 }
52907
52908
52909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
52910   int jresult ;
52911   int result;
52912
52913   {
52914     try {
52915       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
52916     } catch (std::out_of_range& e) {
52917       {
52918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52919       };
52920     } catch (std::exception& e) {
52921       {
52922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52923       };
52924     } catch (...) {
52925       {
52926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52927       };
52928     }
52929   }
52930   jresult = (int)result;
52931   return jresult;
52932 }
52933
52934
52935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
52936   int jresult ;
52937   int result;
52938
52939   {
52940     try {
52941       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
52942     } catch (std::out_of_range& e) {
52943       {
52944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52945       };
52946     } catch (std::exception& e) {
52947       {
52948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52949       };
52950     } catch (...) {
52951       {
52952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52953       };
52954     }
52955   }
52956   jresult = (int)result;
52957   return jresult;
52958 }
52959
52960
52961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
52962   int jresult ;
52963   int result;
52964
52965   {
52966     try {
52967       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
52968     } catch (std::out_of_range& e) {
52969       {
52970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52971       };
52972     } catch (std::exception& e) {
52973       {
52974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52975       };
52976     } catch (...) {
52977       {
52978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52979       };
52980     }
52981   }
52982   jresult = (int)result;
52983   return jresult;
52984 }
52985
52986
52987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
52988   int jresult ;
52989   int result;
52990
52991   {
52992     try {
52993       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
52994     } catch (std::out_of_range& e) {
52995       {
52996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52997       };
52998     } catch (std::exception& e) {
52999       {
53000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53001       };
53002     } catch (...) {
53003       {
53004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53005       };
53006     }
53007   }
53008   jresult = (int)result;
53009   return jresult;
53010 }
53011
53012
53013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
53014   int jresult ;
53015   int result;
53016
53017   {
53018     try {
53019       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
53020     } catch (std::out_of_range& e) {
53021       {
53022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53023       };
53024     } catch (std::exception& e) {
53025       {
53026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53027       };
53028     } catch (...) {
53029       {
53030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53031       };
53032     }
53033   }
53034   jresult = (int)result;
53035   return jresult;
53036 }
53037
53038
53039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
53040   int jresult ;
53041   int result;
53042
53043   {
53044     try {
53045       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
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 = (int)result;
53061   return jresult;
53062 }
53063
53064
53065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
53066   int jresult ;
53067   int result;
53068
53069   {
53070     try {
53071       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
53072     } catch (std::out_of_range& e) {
53073       {
53074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53075       };
53076     } catch (std::exception& e) {
53077       {
53078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53079       };
53080     } catch (...) {
53081       {
53082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53083       };
53084     }
53085   }
53086   jresult = (int)result;
53087   return jresult;
53088 }
53089
53090
53091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
53092   int jresult ;
53093   int result;
53094
53095   {
53096     try {
53097       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
53098     } catch (std::out_of_range& e) {
53099       {
53100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53101       };
53102     } catch (std::exception& e) {
53103       {
53104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53105       };
53106     } catch (...) {
53107       {
53108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53109       };
53110     }
53111   }
53112   jresult = (int)result;
53113   return jresult;
53114 }
53115
53116
53117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
53118   int jresult ;
53119   int result;
53120
53121   {
53122     try {
53123       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
53124     } catch (std::out_of_range& e) {
53125       {
53126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53127       };
53128     } catch (std::exception& e) {
53129       {
53130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53131       };
53132     } catch (...) {
53133       {
53134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53135       };
53136     }
53137   }
53138   jresult = (int)result;
53139   return jresult;
53140 }
53141
53142
53143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
53144   int jresult ;
53145   int result;
53146
53147   {
53148     try {
53149       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
53150     } catch (std::out_of_range& e) {
53151       {
53152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53153       };
53154     } catch (std::exception& e) {
53155       {
53156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53157       };
53158     } catch (...) {
53159       {
53160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53161       };
53162     }
53163   }
53164   jresult = (int)result;
53165   return jresult;
53166 }
53167
53168
53169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
53170   void * jresult ;
53171   Dali::Toolkit::Builder *result = 0 ;
53172
53173   {
53174     try {
53175       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
53176     } catch (std::out_of_range& e) {
53177       {
53178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53179       };
53180     } catch (std::exception& e) {
53181       {
53182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53183       };
53184     } catch (...) {
53185       {
53186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53187       };
53188     }
53189   }
53190   jresult = (void *)result;
53191   return jresult;
53192 }
53193
53194
53195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
53196   void * jresult ;
53197   Dali::Toolkit::Builder result;
53198
53199   {
53200     try {
53201       result = Dali::Toolkit::Builder::New();
53202     } catch (std::out_of_range& e) {
53203       {
53204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53205       };
53206     } catch (std::exception& e) {
53207       {
53208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53209       };
53210     } catch (...) {
53211       {
53212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53213       };
53214     }
53215   }
53216   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
53217   return jresult;
53218 }
53219
53220
53221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
53222   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53223
53224   arg1 = (Dali::Toolkit::Builder *)jarg1;
53225   {
53226     try {
53227       delete arg1;
53228     } catch (std::out_of_range& e) {
53229       {
53230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53231       };
53232     } catch (std::exception& e) {
53233       {
53234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53235       };
53236     } catch (...) {
53237       {
53238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53239       };
53240     }
53241   }
53242 }
53243
53244
53245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
53246   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53247   std::string *arg2 = 0 ;
53248   Dali::Toolkit::Builder::UIFormat arg3 ;
53249
53250   arg1 = (Dali::Toolkit::Builder *)jarg1;
53251   if (!jarg2) {
53252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53253     return ;
53254   }
53255   std::string arg2_str(jarg2);
53256   arg2 = &arg2_str;
53257   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
53258   {
53259     try {
53260       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
53261     } catch (std::out_of_range& e) {
53262       {
53263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53264       };
53265     } catch (std::exception& e) {
53266       {
53267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53268       };
53269     } catch (...) {
53270       {
53271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53272       };
53273     }
53274   }
53275
53276   //argout typemap for const std::string&
53277
53278 }
53279
53280
53281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
53282   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53283   std::string *arg2 = 0 ;
53284
53285   arg1 = (Dali::Toolkit::Builder *)jarg1;
53286   if (!jarg2) {
53287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53288     return ;
53289   }
53290   std::string arg2_str(jarg2);
53291   arg2 = &arg2_str;
53292   {
53293     try {
53294       (arg1)->LoadFromString((std::string const &)*arg2);
53295     } catch (std::out_of_range& e) {
53296       {
53297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53298       };
53299     } catch (std::exception& e) {
53300       {
53301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53302       };
53303     } catch (...) {
53304       {
53305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53306       };
53307     }
53308   }
53309
53310   //argout typemap for const std::string&
53311
53312 }
53313
53314
53315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
53316   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53317   Dali::Property::Map *arg2 = 0 ;
53318
53319   arg1 = (Dali::Toolkit::Builder *)jarg1;
53320   arg2 = (Dali::Property::Map *)jarg2;
53321   if (!arg2) {
53322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53323     return ;
53324   }
53325   {
53326     try {
53327       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
53328     } catch (std::out_of_range& e) {
53329       {
53330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53331       };
53332     } catch (std::exception& e) {
53333       {
53334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53335       };
53336     } catch (...) {
53337       {
53338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53339       };
53340     }
53341   }
53342 }
53343
53344
53345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
53346   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53347   std::string *arg2 = 0 ;
53348   Dali::Property::Value *arg3 = 0 ;
53349
53350   arg1 = (Dali::Toolkit::Builder *)jarg1;
53351   if (!jarg2) {
53352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53353     return ;
53354   }
53355   std::string arg2_str(jarg2);
53356   arg2 = &arg2_str;
53357   arg3 = (Dali::Property::Value *)jarg3;
53358   if (!arg3) {
53359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
53360     return ;
53361   }
53362   {
53363     try {
53364       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
53365     } catch (std::out_of_range& e) {
53366       {
53367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53368       };
53369     } catch (std::exception& e) {
53370       {
53371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53372       };
53373     } catch (...) {
53374       {
53375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53376       };
53377     }
53378   }
53379
53380   //argout typemap for const std::string&
53381
53382 }
53383
53384
53385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
53386   void * jresult ;
53387   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53388   Dali::Property::Map *result = 0 ;
53389
53390   arg1 = (Dali::Toolkit::Builder *)jarg1;
53391   {
53392     try {
53393       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
53394     } catch (std::out_of_range& e) {
53395       {
53396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53397       };
53398     } catch (std::exception& e) {
53399       {
53400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53401       };
53402     } catch (...) {
53403       {
53404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53405       };
53406     }
53407   }
53408   jresult = (void *)result;
53409   return jresult;
53410 }
53411
53412
53413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
53414   void * jresult ;
53415   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53416   std::string *arg2 = 0 ;
53417   Dali::Property::Value *result = 0 ;
53418
53419   arg1 = (Dali::Toolkit::Builder *)jarg1;
53420   if (!jarg2) {
53421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53422     return 0;
53423   }
53424   std::string arg2_str(jarg2);
53425   arg2 = &arg2_str;
53426   {
53427     try {
53428       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
53429     } catch (std::out_of_range& e) {
53430       {
53431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53432       };
53433     } catch (std::exception& e) {
53434       {
53435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53436       };
53437     } catch (...) {
53438       {
53439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53440       };
53441     }
53442   }
53443   jresult = (void *)result;
53444
53445   //argout typemap for const std::string&
53446
53447   return jresult;
53448 }
53449
53450
53451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
53452   void * jresult ;
53453   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53454   std::string *arg2 = 0 ;
53455   Dali::Animation result;
53456
53457   arg1 = (Dali::Toolkit::Builder *)jarg1;
53458   if (!jarg2) {
53459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53460     return 0;
53461   }
53462   std::string arg2_str(jarg2);
53463   arg2 = &arg2_str;
53464   {
53465     try {
53466       result = (arg1)->CreateAnimation((std::string const &)*arg2);
53467     } catch (std::out_of_range& e) {
53468       {
53469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53470       };
53471     } catch (std::exception& e) {
53472       {
53473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53474       };
53475     } catch (...) {
53476       {
53477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53478       };
53479     }
53480   }
53481   jresult = new Dali::Animation((const Dali::Animation &)result);
53482
53483   //argout typemap for const std::string&
53484
53485   return jresult;
53486 }
53487
53488
53489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53490   void * jresult ;
53491   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53492   std::string *arg2 = 0 ;
53493   Dali::Property::Map *arg3 = 0 ;
53494   Dali::Animation result;
53495
53496   arg1 = (Dali::Toolkit::Builder *)jarg1;
53497   if (!jarg2) {
53498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53499     return 0;
53500   }
53501   std::string arg2_str(jarg2);
53502   arg2 = &arg2_str;
53503   arg3 = (Dali::Property::Map *)jarg3;
53504   if (!arg3) {
53505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53506     return 0;
53507   }
53508   {
53509     try {
53510       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
53511     } catch (std::out_of_range& e) {
53512       {
53513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53514       };
53515     } catch (std::exception& e) {
53516       {
53517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53518       };
53519     } catch (...) {
53520       {
53521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53522       };
53523     }
53524   }
53525   jresult = new Dali::Animation((const Dali::Animation &)result);
53526
53527   //argout typemap for const std::string&
53528
53529   return jresult;
53530 }
53531
53532
53533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
53534   void * jresult ;
53535   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53536   std::string *arg2 = 0 ;
53537   Dali::Actor arg3 ;
53538   Dali::Actor *argp3 ;
53539   Dali::Animation result;
53540
53541   arg1 = (Dali::Toolkit::Builder *)jarg1;
53542   if (!jarg2) {
53543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53544     return 0;
53545   }
53546   std::string arg2_str(jarg2);
53547   arg2 = &arg2_str;
53548   argp3 = (Dali::Actor *)jarg3;
53549   if (!argp3) {
53550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53551     return 0;
53552   }
53553   arg3 = *argp3;
53554   {
53555     try {
53556       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
53557     } catch (std::out_of_range& e) {
53558       {
53559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53560       };
53561     } catch (std::exception& e) {
53562       {
53563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53564       };
53565     } catch (...) {
53566       {
53567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53568       };
53569     }
53570   }
53571   jresult = new Dali::Animation((const Dali::Animation &)result);
53572
53573   //argout typemap for const std::string&
53574
53575   return jresult;
53576 }
53577
53578
53579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
53580   void * jresult ;
53581   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53582   std::string *arg2 = 0 ;
53583   Dali::Property::Map *arg3 = 0 ;
53584   Dali::Actor arg4 ;
53585   Dali::Actor *argp4 ;
53586   Dali::Animation result;
53587
53588   arg1 = (Dali::Toolkit::Builder *)jarg1;
53589   if (!jarg2) {
53590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53591     return 0;
53592   }
53593   std::string arg2_str(jarg2);
53594   arg2 = &arg2_str;
53595   arg3 = (Dali::Property::Map *)jarg3;
53596   if (!arg3) {
53597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53598     return 0;
53599   }
53600   argp4 = (Dali::Actor *)jarg4;
53601   if (!argp4) {
53602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53603     return 0;
53604   }
53605   arg4 = *argp4;
53606   {
53607     try {
53608       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
53609     } catch (std::out_of_range& e) {
53610       {
53611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53612       };
53613     } catch (std::exception& e) {
53614       {
53615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53616       };
53617     } catch (...) {
53618       {
53619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53620       };
53621     }
53622   }
53623   jresult = new Dali::Animation((const Dali::Animation &)result);
53624
53625   //argout typemap for const std::string&
53626
53627   return jresult;
53628 }
53629
53630
53631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
53632   void * jresult ;
53633   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53634   std::string *arg2 = 0 ;
53635   Dali::BaseHandle result;
53636
53637   arg1 = (Dali::Toolkit::Builder *)jarg1;
53638   if (!jarg2) {
53639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53640     return 0;
53641   }
53642   std::string arg2_str(jarg2);
53643   arg2 = &arg2_str;
53644   {
53645     try {
53646       result = (arg1)->Create((std::string const &)*arg2);
53647     } catch (std::out_of_range& e) {
53648       {
53649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53650       };
53651     } catch (std::exception& e) {
53652       {
53653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53654       };
53655     } catch (...) {
53656       {
53657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53658       };
53659     }
53660   }
53661   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53662
53663   //argout typemap for const std::string&
53664
53665   return jresult;
53666 }
53667
53668
53669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53670   void * jresult ;
53671   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53672   std::string *arg2 = 0 ;
53673   Dali::Property::Map *arg3 = 0 ;
53674   Dali::BaseHandle result;
53675
53676   arg1 = (Dali::Toolkit::Builder *)jarg1;
53677   if (!jarg2) {
53678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53679     return 0;
53680   }
53681   std::string arg2_str(jarg2);
53682   arg2 = &arg2_str;
53683   arg3 = (Dali::Property::Map *)jarg3;
53684   if (!arg3) {
53685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53686     return 0;
53687   }
53688   {
53689     try {
53690       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
53691     } catch (std::out_of_range& e) {
53692       {
53693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53694       };
53695     } catch (std::exception& e) {
53696       {
53697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53698       };
53699     } catch (...) {
53700       {
53701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53702       };
53703     }
53704   }
53705   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53706
53707   //argout typemap for const std::string&
53708
53709   return jresult;
53710 }
53711
53712
53713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
53714   void * jresult ;
53715   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53716   std::string *arg2 = 0 ;
53717   Dali::BaseHandle result;
53718
53719   arg1 = (Dali::Toolkit::Builder *)jarg1;
53720   if (!jarg2) {
53721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53722     return 0;
53723   }
53724   std::string arg2_str(jarg2);
53725   arg2 = &arg2_str;
53726   {
53727     try {
53728       result = (arg1)->CreateFromJson((std::string const &)*arg2);
53729     } catch (std::out_of_range& e) {
53730       {
53731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53732       };
53733     } catch (std::exception& e) {
53734       {
53735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53736       };
53737     } catch (...) {
53738       {
53739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53740       };
53741     }
53742   }
53743   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53744
53745   //argout typemap for const std::string&
53746
53747   return jresult;
53748 }
53749
53750
53751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
53752   unsigned int jresult ;
53753   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53754   std::string *arg2 = 0 ;
53755   Dali::Handle *arg3 = 0 ;
53756   bool result;
53757
53758   arg1 = (Dali::Toolkit::Builder *)jarg1;
53759   if (!jarg2) {
53760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53761     return 0;
53762   }
53763   std::string arg2_str(jarg2);
53764   arg2 = &arg2_str;
53765   arg3 = (Dali::Handle *)jarg3;
53766   if (!arg3) {
53767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
53768     return 0;
53769   }
53770   {
53771     try {
53772       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
53773     } catch (std::out_of_range& e) {
53774       {
53775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53776       };
53777     } catch (std::exception& e) {
53778       {
53779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53780       };
53781     } catch (...) {
53782       {
53783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53784       };
53785     }
53786   }
53787   jresult = result;
53788
53789   //argout typemap for const std::string&
53790
53791   return jresult;
53792 }
53793
53794
53795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
53796   unsigned int jresult ;
53797   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53798   Dali::Handle *arg2 = 0 ;
53799   std::string *arg3 = 0 ;
53800   bool result;
53801
53802   arg1 = (Dali::Toolkit::Builder *)jarg1;
53803   arg2 = (Dali::Handle *)jarg2;
53804   if (!arg2) {
53805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
53806     return 0;
53807   }
53808   if (!jarg3) {
53809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53810     return 0;
53811   }
53812   std::string arg3_str(jarg3);
53813   arg3 = &arg3_str;
53814   {
53815     try {
53816       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
53817     } catch (std::out_of_range& e) {
53818       {
53819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53820       };
53821     } catch (std::exception& e) {
53822       {
53823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53824       };
53825     } catch (...) {
53826       {
53827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53828       };
53829     }
53830   }
53831   jresult = result;
53832
53833   //argout typemap for const std::string&
53834
53835   return jresult;
53836 }
53837
53838
53839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
53840   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53841   Dali::Actor arg2 ;
53842   Dali::Actor *argp2 ;
53843
53844   arg1 = (Dali::Toolkit::Builder *)jarg1;
53845   argp2 = (Dali::Actor *)jarg2;
53846   if (!argp2) {
53847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53848     return ;
53849   }
53850   arg2 = *argp2;
53851   {
53852     try {
53853       (arg1)->AddActors(arg2);
53854     } catch (std::out_of_range& e) {
53855       {
53856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53857       };
53858     } catch (std::exception& e) {
53859       {
53860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53861       };
53862     } catch (...) {
53863       {
53864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53865       };
53866     }
53867   }
53868 }
53869
53870
53871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53872   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53873   std::string *arg2 = 0 ;
53874   Dali::Actor arg3 ;
53875   Dali::Actor *argp3 ;
53876
53877   arg1 = (Dali::Toolkit::Builder *)jarg1;
53878   if (!jarg2) {
53879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53880     return ;
53881   }
53882   std::string arg2_str(jarg2);
53883   arg2 = &arg2_str;
53884   argp3 = (Dali::Actor *)jarg3;
53885   if (!argp3) {
53886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53887     return ;
53888   }
53889   arg3 = *argp3;
53890   {
53891     try {
53892       (arg1)->AddActors((std::string const &)*arg2,arg3);
53893     } catch (std::out_of_range& e) {
53894       {
53895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53896       };
53897     } catch (std::exception& e) {
53898       {
53899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53900       };
53901     } catch (...) {
53902       {
53903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53904       };
53905     }
53906   }
53907
53908   //argout typemap for const std::string&
53909
53910 }
53911
53912
53913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
53914   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53915   std::string *arg2 = 0 ;
53916
53917   arg1 = (Dali::Toolkit::Builder *)jarg1;
53918   if (!jarg2) {
53919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53920     return ;
53921   }
53922   std::string arg2_str(jarg2);
53923   arg2 = &arg2_str;
53924   {
53925     try {
53926       (arg1)->CreateRenderTask((std::string const &)*arg2);
53927     } catch (std::out_of_range& e) {
53928       {
53929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53930       };
53931     } catch (std::exception& e) {
53932       {
53933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53934       };
53935     } catch (...) {
53936       {
53937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53938       };
53939     }
53940   }
53941
53942   //argout typemap for const std::string&
53943
53944 }
53945
53946
53947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
53948   void * jresult ;
53949   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53950   std::string *arg2 = 0 ;
53951   Dali::FrameBufferImage result;
53952
53953   arg1 = (Dali::Toolkit::Builder *)jarg1;
53954   if (!jarg2) {
53955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53956     return 0;
53957   }
53958   std::string arg2_str(jarg2);
53959   arg2 = &arg2_str;
53960   {
53961     try {
53962       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
53963     } catch (std::out_of_range& e) {
53964       {
53965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53966       };
53967     } catch (std::exception& e) {
53968       {
53969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53970       };
53971     } catch (...) {
53972       {
53973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53974       };
53975     }
53976   }
53977   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
53978
53979   //argout typemap for const std::string&
53980
53981   return jresult;
53982 }
53983
53984
53985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
53986   void * jresult ;
53987   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53988   std::string *arg2 = 0 ;
53989   Dali::Path result;
53990
53991   arg1 = (Dali::Toolkit::Builder *)jarg1;
53992   if (!jarg2) {
53993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53994     return 0;
53995   }
53996   std::string arg2_str(jarg2);
53997   arg2 = &arg2_str;
53998   {
53999     try {
54000       result = (arg1)->GetPath((std::string const &)*arg2);
54001     } catch (std::out_of_range& e) {
54002       {
54003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54004       };
54005     } catch (std::exception& e) {
54006       {
54007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54008       };
54009     } catch (...) {
54010       {
54011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54012       };
54013     }
54014   }
54015   jresult = new Dali::Path((const Dali::Path &)result);
54016
54017   //argout typemap for const std::string&
54018
54019   return jresult;
54020 }
54021
54022
54023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
54024   void * jresult ;
54025   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54026   std::string *arg2 = 0 ;
54027   Dali::PathConstrainer result;
54028
54029   arg1 = (Dali::Toolkit::Builder *)jarg1;
54030   if (!jarg2) {
54031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54032     return 0;
54033   }
54034   std::string arg2_str(jarg2);
54035   arg2 = &arg2_str;
54036   {
54037     try {
54038       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
54039     } catch (std::out_of_range& e) {
54040       {
54041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54042       };
54043     } catch (std::exception& e) {
54044       {
54045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54046       };
54047     } catch (...) {
54048       {
54049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54050       };
54051     }
54052   }
54053   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
54054
54055   //argout typemap for const std::string&
54056
54057   return jresult;
54058 }
54059
54060
54061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
54062   void * jresult ;
54063   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54064   std::string *arg2 = 0 ;
54065   Dali::LinearConstrainer result;
54066
54067   arg1 = (Dali::Toolkit::Builder *)jarg1;
54068   if (!jarg2) {
54069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54070     return 0;
54071   }
54072   std::string arg2_str(jarg2);
54073   arg2 = &arg2_str;
54074   {
54075     try {
54076       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
54077     } catch (std::out_of_range& e) {
54078       {
54079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54080       };
54081     } catch (std::exception& e) {
54082       {
54083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54084       };
54085     } catch (...) {
54086       {
54087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54088       };
54089     }
54090   }
54091   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
54092
54093   //argout typemap for const std::string&
54094
54095   return jresult;
54096 }
54097
54098
54099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
54100   void * jresult ;
54101   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54102   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
54103
54104   arg1 = (Dali::Toolkit::Builder *)jarg1;
54105   {
54106     try {
54107       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
54108     } catch (std::out_of_range& e) {
54109       {
54110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54111       };
54112     } catch (std::exception& e) {
54113       {
54114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54115       };
54116     } catch (...) {
54117       {
54118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54119       };
54120     }
54121   }
54122   jresult = (void *)result;
54123   return jresult;
54124 }
54125
54126
54127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
54128   void * jresult ;
54129   Dali::Toolkit::TransitionData *result = 0 ;
54130
54131   {
54132     try {
54133       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
54134     } catch (std::out_of_range& e) {
54135       {
54136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54137       };
54138     } catch (std::exception& e) {
54139       {
54140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54141       };
54142     } catch (...) {
54143       {
54144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54145       };
54146     }
54147   }
54148   jresult = (void *)result;
54149   return jresult;
54150 }
54151
54152
54153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
54154   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54155
54156   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54157   {
54158     try {
54159       delete arg1;
54160     } catch (std::out_of_range& e) {
54161       {
54162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54163       };
54164     } catch (std::exception& e) {
54165       {
54166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54167       };
54168     } catch (...) {
54169       {
54170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54171       };
54172     }
54173   }
54174 }
54175
54176
54177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
54178   void * jresult ;
54179   Dali::Property::Map *arg1 = 0 ;
54180   Dali::Toolkit::TransitionData result;
54181
54182   arg1 = (Dali::Property::Map *)jarg1;
54183   if (!arg1) {
54184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
54185     return 0;
54186   }
54187   {
54188     try {
54189       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
54190     } catch (std::out_of_range& e) {
54191       {
54192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54193       };
54194     } catch (std::exception& e) {
54195       {
54196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54197       };
54198     } catch (...) {
54199       {
54200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54201       };
54202     }
54203   }
54204   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54205   return jresult;
54206 }
54207
54208
54209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
54210   void * jresult ;
54211   Dali::Property::Array *arg1 = 0 ;
54212   Dali::Toolkit::TransitionData result;
54213
54214   arg1 = (Dali::Property::Array *)jarg1;
54215   if (!arg1) {
54216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
54217     return 0;
54218   }
54219   {
54220     try {
54221       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
54222     } catch (std::out_of_range& e) {
54223       {
54224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54225       };
54226     } catch (std::exception& e) {
54227       {
54228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54229       };
54230     } catch (...) {
54231       {
54232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54233       };
54234     }
54235   }
54236   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54237   return jresult;
54238 }
54239
54240
54241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
54242   void * jresult ;
54243   Dali::BaseHandle arg1 ;
54244   Dali::BaseHandle *argp1 ;
54245   Dali::Toolkit::TransitionData result;
54246
54247   argp1 = (Dali::BaseHandle *)jarg1;
54248   if (!argp1) {
54249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54250     return 0;
54251   }
54252   arg1 = *argp1;
54253   {
54254     try {
54255       result = Dali::Toolkit::TransitionData::DownCast(arg1);
54256     } catch (std::out_of_range& e) {
54257       {
54258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54259       };
54260     } catch (std::exception& e) {
54261       {
54262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54263       };
54264     } catch (...) {
54265       {
54266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54267       };
54268     }
54269   }
54270   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54271   return jresult;
54272 }
54273
54274
54275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
54276   void * jresult ;
54277   Dali::Toolkit::TransitionData *arg1 = 0 ;
54278   Dali::Toolkit::TransitionData *result = 0 ;
54279
54280   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54281   if (!arg1) {
54282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
54283     return 0;
54284   }
54285   {
54286     try {
54287       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
54288     } catch (std::out_of_range& e) {
54289       {
54290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54291       };
54292     } catch (std::exception& e) {
54293       {
54294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54295       };
54296     } catch (...) {
54297       {
54298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54299       };
54300     }
54301   }
54302   jresult = (void *)result;
54303   return jresult;
54304 }
54305
54306
54307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
54308   void * jresult ;
54309   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54310   Dali::Toolkit::TransitionData *arg2 = 0 ;
54311   Dali::Toolkit::TransitionData *result = 0 ;
54312
54313   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54314   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
54315   if (!arg2) {
54316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
54317     return 0;
54318   }
54319   {
54320     try {
54321       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
54322     } catch (std::out_of_range& e) {
54323       {
54324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54325       };
54326     } catch (std::exception& e) {
54327       {
54328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54329       };
54330     } catch (...) {
54331       {
54332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54333       };
54334     }
54335   }
54336   jresult = (void *)result;
54337   return jresult;
54338 }
54339
54340
54341 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
54342   unsigned long jresult ;
54343   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54344   size_t result;
54345
54346   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54347   {
54348     try {
54349       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
54350     } catch (std::out_of_range& e) {
54351       {
54352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54353       };
54354     } catch (std::exception& e) {
54355       {
54356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54357       };
54358     } catch (...) {
54359       {
54360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54361       };
54362     }
54363   }
54364   jresult = (unsigned long)result;
54365   return jresult;
54366 }
54367
54368
54369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
54370   void * jresult ;
54371   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54372   size_t arg2 ;
54373   Dali::Property::Map result;
54374
54375   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54376   arg2 = (size_t)jarg2;
54377   {
54378     try {
54379       result = (arg1)->GetAnimatorAt(arg2);
54380     } catch (std::out_of_range& e) {
54381       {
54382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54383       };
54384     } catch (std::exception& e) {
54385       {
54386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54387       };
54388     } catch (...) {
54389       {
54390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54391       };
54392     }
54393   }
54394   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
54395   return jresult;
54396 }
54397
54398
54399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
54400   void * jresult ;
54401   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
54402   Dali::Toolkit::TransitionData *result = 0 ;
54403
54404   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
54405   {
54406     try {
54407       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
54408     } catch (std::out_of_range& e) {
54409       {
54410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54411       };
54412     } catch (std::exception& e) {
54413       {
54414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54415       };
54416     } catch (...) {
54417       {
54418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54419       };
54420     }
54421   }
54422   jresult = (void *)result;
54423   return jresult;
54424 }
54425
54426
54427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
54428   int jresult ;
54429   int result;
54430
54431   {
54432     try {
54433       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
54434     } catch (std::out_of_range& e) {
54435       {
54436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54437       };
54438     } catch (std::exception& e) {
54439       {
54440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54441       };
54442     } catch (...) {
54443       {
54444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54445       };
54446     }
54447   }
54448   jresult = (int)result;
54449   return jresult;
54450 }
54451
54452
54453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
54454   int jresult ;
54455   int result;
54456
54457   {
54458     try {
54459       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
54460     } catch (std::out_of_range& e) {
54461       {
54462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54463       };
54464     } catch (std::exception& e) {
54465       {
54466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54467       };
54468     } catch (...) {
54469       {
54470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54471       };
54472     }
54473   }
54474   jresult = (int)result;
54475   return jresult;
54476 }
54477
54478
54479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
54480   int jresult ;
54481   int result;
54482
54483   {
54484     try {
54485       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
54486     } catch (std::out_of_range& e) {
54487       {
54488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54489       };
54490     } catch (std::exception& e) {
54491       {
54492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54493       };
54494     } catch (...) {
54495       {
54496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54497       };
54498     }
54499   }
54500   jresult = (int)result;
54501   return jresult;
54502 }
54503
54504
54505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
54506   int jresult ;
54507   int result;
54508
54509   {
54510     try {
54511       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
54512     } catch (std::out_of_range& e) {
54513       {
54514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54515       };
54516     } catch (std::exception& e) {
54517       {
54518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54519       };
54520     } catch (...) {
54521       {
54522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54523       };
54524     }
54525   }
54526   jresult = (int)result;
54527   return jresult;
54528 }
54529
54530
54531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
54532   int jresult ;
54533   int result;
54534
54535   {
54536     try {
54537       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
54538     } catch (std::out_of_range& e) {
54539       {
54540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54541       };
54542     } catch (std::exception& e) {
54543       {
54544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54545       };
54546     } catch (...) {
54547       {
54548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54549       };
54550     }
54551   }
54552   jresult = (int)result;
54553   return jresult;
54554 }
54555
54556
54557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
54558   int jresult ;
54559   int result;
54560
54561   {
54562     try {
54563       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
54564     } catch (std::out_of_range& e) {
54565       {
54566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54567       };
54568     } catch (std::exception& e) {
54569       {
54570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54571       };
54572     } catch (...) {
54573       {
54574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54575       };
54576     }
54577   }
54578   jresult = (int)result;
54579   return jresult;
54580 }
54581
54582
54583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
54584   int jresult ;
54585   int result;
54586
54587   {
54588     try {
54589       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
54590     } catch (std::out_of_range& e) {
54591       {
54592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54593       };
54594     } catch (std::exception& e) {
54595       {
54596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54597       };
54598     } catch (...) {
54599       {
54600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54601       };
54602     }
54603   }
54604   jresult = (int)result;
54605   return jresult;
54606 }
54607
54608
54609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
54610   int jresult ;
54611   int result;
54612
54613   {
54614     try {
54615       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
54616     } catch (std::out_of_range& e) {
54617       {
54618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54619       };
54620     } catch (std::exception& e) {
54621       {
54622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54623       };
54624     } catch (...) {
54625       {
54626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54627       };
54628     }
54629   }
54630   jresult = (int)result;
54631   return jresult;
54632 }
54633
54634
54635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
54636   int jresult ;
54637   int result;
54638
54639   {
54640     try {
54641       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
54642     } catch (std::out_of_range& e) {
54643       {
54644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54645       };
54646     } catch (std::exception& e) {
54647       {
54648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54649       };
54650     } catch (...) {
54651       {
54652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54653       };
54654     }
54655   }
54656   jresult = (int)result;
54657   return jresult;
54658 }
54659
54660
54661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
54662   int jresult ;
54663   int result;
54664
54665   {
54666     try {
54667       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
54668     } catch (std::out_of_range& e) {
54669       {
54670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54671       };
54672     } catch (std::exception& e) {
54673       {
54674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54675       };
54676     } catch (...) {
54677       {
54678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54679       };
54680     }
54681   }
54682   jresult = (int)result;
54683   return jresult;
54684 }
54685
54686
54687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
54688   int jresult ;
54689   int result;
54690
54691   {
54692     try {
54693       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
54694     } catch (std::out_of_range& e) {
54695       {
54696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54697       };
54698     } catch (std::exception& e) {
54699       {
54700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54701       };
54702     } catch (...) {
54703       {
54704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54705       };
54706     }
54707   }
54708   jresult = (int)result;
54709   return jresult;
54710 }
54711
54712
54713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
54714   int jresult ;
54715   int result;
54716
54717   {
54718     try {
54719       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
54720     } catch (std::out_of_range& e) {
54721       {
54722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54723       };
54724     } catch (std::exception& e) {
54725       {
54726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54727       };
54728     } catch (...) {
54729       {
54730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54731       };
54732     }
54733   }
54734   jresult = (int)result;
54735   return jresult;
54736 }
54737
54738
54739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
54740   int jresult ;
54741   int result;
54742
54743   {
54744     try {
54745       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
54746     } catch (std::out_of_range& e) {
54747       {
54748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54749       };
54750     } catch (std::exception& e) {
54751       {
54752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54753       };
54754     } catch (...) {
54755       {
54756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54757       };
54758     }
54759   }
54760   jresult = (int)result;
54761   return jresult;
54762 }
54763
54764
54765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
54766   int jresult ;
54767   int result;
54768
54769   {
54770     try {
54771       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
54772     } catch (std::out_of_range& e) {
54773       {
54774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54775       };
54776     } catch (std::exception& e) {
54777       {
54778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54779       };
54780     } catch (...) {
54781       {
54782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54783       };
54784     }
54785   }
54786   jresult = (int)result;
54787   return jresult;
54788 }
54789
54790
54791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
54792   void * jresult ;
54793   Dali::Toolkit::Control result;
54794
54795   {
54796     try {
54797       result = Dali::Toolkit::Internal::Control::New();
54798     } catch (std::out_of_range& e) {
54799       {
54800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54801       };
54802     } catch (std::exception& e) {
54803       {
54804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54805       };
54806     } catch (...) {
54807       {
54808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54809       };
54810     }
54811   }
54812   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
54813   return jresult;
54814 }
54815
54816
54817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
54818   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54819   std::string *arg2 = 0 ;
54820
54821   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54822   if (!jarg2) {
54823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54824     return ;
54825   }
54826   std::string arg2_str(jarg2);
54827   arg2 = &arg2_str;
54828   {
54829     try {
54830       (arg1)->SetStyleName((std::string const &)*arg2);
54831     } catch (std::out_of_range& e) {
54832       {
54833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54834       };
54835     } catch (std::exception& e) {
54836       {
54837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54838       };
54839     } catch (...) {
54840       {
54841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54842       };
54843     }
54844   }
54845
54846   //argout typemap for const std::string&
54847
54848 }
54849
54850
54851 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
54852   char * jresult ;
54853   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54854   std::string *result = 0 ;
54855
54856   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54857   {
54858     try {
54859       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
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 = SWIG_csharp_string_callback(result->c_str());
54875   return jresult;
54876 }
54877
54878
54879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
54880   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54881   Dali::Vector4 *arg2 = 0 ;
54882
54883   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54884   arg2 = (Dali::Vector4 *)jarg2;
54885   if (!arg2) {
54886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
54887     return ;
54888   }
54889   {
54890     try {
54891       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
54892     } catch (std::out_of_range& e) {
54893       {
54894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54895       };
54896     } catch (std::exception& e) {
54897       {
54898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54899       };
54900     } catch (...) {
54901       {
54902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54903       };
54904     }
54905   }
54906 }
54907
54908
54909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
54910   void * jresult ;
54911   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54912   Dali::Vector4 result;
54913
54914   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54915   {
54916     try {
54917       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
54918     } catch (std::out_of_range& e) {
54919       {
54920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54921       };
54922     } catch (std::exception& e) {
54923       {
54924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54925       };
54926     } catch (...) {
54927       {
54928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54929       };
54930     }
54931   }
54932   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
54933   return jresult;
54934 }
54935
54936
54937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
54938   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54939   Dali::Image arg2 ;
54940   Dali::Image *argp2 ;
54941
54942   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54943   argp2 = (Dali::Image *)jarg2;
54944   if (!argp2) {
54945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54946     return ;
54947   }
54948   arg2 = *argp2;
54949   {
54950     try {
54951       (arg1)->SetBackgroundImage(arg2);
54952     } catch (std::out_of_range& e) {
54953       {
54954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54955       };
54956     } catch (std::exception& e) {
54957       {
54958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54959       };
54960     } catch (...) {
54961       {
54962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54963       };
54964     }
54965   }
54966 }
54967
54968
54969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
54970   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54971   Dali::Property::Map *arg2 = 0 ;
54972
54973   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54974   arg2 = (Dali::Property::Map *)jarg2;
54975   if (!arg2) {
54976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
54977     return ;
54978   }
54979   {
54980     try {
54981       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
54982     } catch (std::out_of_range& e) {
54983       {
54984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54985       };
54986     } catch (std::exception& e) {
54987       {
54988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54989       };
54990     } catch (...) {
54991       {
54992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54993       };
54994     }
54995   }
54996 }
54997
54998
54999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
55000   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55001
55002   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55003   {
55004     try {
55005       (arg1)->ClearBackground();
55006     } catch (std::out_of_range& e) {
55007       {
55008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55009       };
55010     } catch (std::exception& e) {
55011       {
55012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55013       };
55014     } catch (...) {
55015       {
55016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55017       };
55018     }
55019   }
55020 }
55021
55022
55023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
55024   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55025   Dali::Gesture::Type arg2 ;
55026
55027   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55028   arg2 = (Dali::Gesture::Type)jarg2;
55029   {
55030     try {
55031       (arg1)->EnableGestureDetection(arg2);
55032     } catch (std::out_of_range& e) {
55033       {
55034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55035       };
55036     } catch (std::exception& e) {
55037       {
55038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55039       };
55040     } catch (...) {
55041       {
55042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55043       };
55044     }
55045   }
55046 }
55047
55048
55049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
55050   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55051   Dali::Gesture::Type arg2 ;
55052
55053   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55054   arg2 = (Dali::Gesture::Type)jarg2;
55055   {
55056     try {
55057       (arg1)->DisableGestureDetection(arg2);
55058     } catch (std::out_of_range& e) {
55059       {
55060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55061       };
55062     } catch (std::exception& e) {
55063       {
55064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55065       };
55066     } catch (...) {
55067       {
55068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55069       };
55070     }
55071   }
55072 }
55073
55074
55075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
55076   void * jresult ;
55077   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55078   Dali::PinchGestureDetector result;
55079
55080   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55081   {
55082     try {
55083       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
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 = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
55099   return jresult;
55100 }
55101
55102
55103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
55104   void * jresult ;
55105   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55106   Dali::PanGestureDetector result;
55107
55108   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55109   {
55110     try {
55111       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
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 = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
55127   return jresult;
55128 }
55129
55130
55131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
55132   void * jresult ;
55133   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55134   Dali::TapGestureDetector result;
55135
55136   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55137   {
55138     try {
55139       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
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 = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
55155   return jresult;
55156 }
55157
55158
55159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
55160   void * jresult ;
55161   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55162   Dali::LongPressGestureDetector result;
55163
55164   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55165   {
55166     try {
55167       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
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 = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
55183   return jresult;
55184 }
55185
55186
55187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
55188   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55189   bool arg2 ;
55190
55191   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55192   arg2 = jarg2 ? true : false;
55193   {
55194     try {
55195       (arg1)->SetKeyboardNavigationSupport(arg2);
55196     } catch (std::out_of_range& e) {
55197       {
55198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55199       };
55200     } catch (std::exception& e) {
55201       {
55202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55203       };
55204     } catch (...) {
55205       {
55206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55207       };
55208     }
55209   }
55210 }
55211
55212
55213 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
55214   unsigned int jresult ;
55215   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55216   bool result;
55217
55218   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55219   {
55220     try {
55221       result = (bool)(arg1)->IsKeyboardNavigationSupported();
55222     } catch (std::out_of_range& e) {
55223       {
55224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55225       };
55226     } catch (std::exception& e) {
55227       {
55228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55229       };
55230     } catch (...) {
55231       {
55232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55233       };
55234     }
55235   }
55236   jresult = result;
55237   return jresult;
55238 }
55239
55240
55241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
55242   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55243
55244   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55245   {
55246     try {
55247       (arg1)->SetKeyInputFocus();
55248     } catch (std::out_of_range& e) {
55249       {
55250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55251       };
55252     } catch (std::exception& e) {
55253       {
55254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55255       };
55256     } catch (...) {
55257       {
55258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55259       };
55260     }
55261   }
55262 }
55263
55264
55265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
55266   unsigned int jresult ;
55267   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55268   bool result;
55269
55270   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55271   {
55272     try {
55273       result = (bool)(arg1)->HasKeyInputFocus();
55274     } catch (std::out_of_range& e) {
55275       {
55276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55277       };
55278     } catch (std::exception& e) {
55279       {
55280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55281       };
55282     } catch (...) {
55283       {
55284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55285       };
55286     }
55287   }
55288   jresult = result;
55289   return jresult;
55290 }
55291
55292
55293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
55294   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55295
55296   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55297   {
55298     try {
55299       (arg1)->ClearKeyInputFocus();
55300     } catch (std::out_of_range& e) {
55301       {
55302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55303       };
55304     } catch (std::exception& e) {
55305       {
55306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55307       };
55308     } catch (...) {
55309       {
55310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55311       };
55312     }
55313   }
55314 }
55315
55316
55317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
55318   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55319   bool arg2 ;
55320
55321   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55322   arg2 = jarg2 ? true : false;
55323   {
55324     try {
55325       (arg1)->SetAsKeyboardFocusGroup(arg2);
55326     } catch (std::out_of_range& e) {
55327       {
55328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55329       };
55330     } catch (std::exception& e) {
55331       {
55332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55333       };
55334     } catch (...) {
55335       {
55336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55337       };
55338     }
55339   }
55340 }
55341
55342
55343 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
55344   unsigned int jresult ;
55345   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55346   bool result;
55347
55348   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55349   {
55350     try {
55351       result = (bool)(arg1)->IsKeyboardFocusGroup();
55352     } catch (std::out_of_range& e) {
55353       {
55354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55355       };
55356     } catch (std::exception& e) {
55357       {
55358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55359       };
55360     } catch (...) {
55361       {
55362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55363       };
55364     }
55365   }
55366   jresult = result;
55367   return jresult;
55368 }
55369
55370
55371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
55372   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55373
55374   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55375   {
55376     try {
55377       (arg1)->AccessibilityActivate();
55378     } catch (std::out_of_range& e) {
55379       {
55380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55381       };
55382     } catch (std::exception& e) {
55383       {
55384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55385       };
55386     } catch (...) {
55387       {
55388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55389       };
55390     }
55391   }
55392 }
55393
55394
55395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
55396   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55397
55398   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55399   {
55400     try {
55401       (arg1)->KeyboardEnter();
55402     } catch (std::out_of_range& e) {
55403       {
55404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55405       };
55406     } catch (std::exception& e) {
55407       {
55408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55409       };
55410     } catch (...) {
55411       {
55412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55413       };
55414     }
55415   }
55416 }
55417
55418
55419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
55420   void * jresult ;
55421   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55422   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
55423
55424   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55425   {
55426     try {
55427       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
55428     } catch (std::out_of_range& e) {
55429       {
55430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55431       };
55432     } catch (std::exception& e) {
55433       {
55434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55435       };
55436     } catch (...) {
55437       {
55438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55439       };
55440     }
55441   }
55442   jresult = (void *)result;
55443   return jresult;
55444 }
55445
55446
55447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
55448   void * jresult ;
55449   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55450   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
55451
55452   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55453   {
55454     try {
55455       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
55456     } catch (std::out_of_range& e) {
55457       {
55458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55459       };
55460     } catch (std::exception& e) {
55461       {
55462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55463       };
55464     } catch (...) {
55465       {
55466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55467       };
55468     }
55469   }
55470   jresult = (void *)result;
55471   return jresult;
55472 }
55473
55474
55475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
55476   void * jresult ;
55477   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55478   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
55479
55480   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55481   {
55482     try {
55483       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
55484     } catch (std::out_of_range& e) {
55485       {
55486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55487       };
55488     } catch (std::exception& e) {
55489       {
55490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55491       };
55492     } catch (...) {
55493       {
55494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55495       };
55496     }
55497   }
55498   jresult = (void *)result;
55499   return jresult;
55500 }
55501
55502
55503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
55504   unsigned int jresult ;
55505   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55506   Dali::KeyEvent *arg2 = 0 ;
55507   bool result;
55508
55509   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55510   arg2 = (Dali::KeyEvent *)jarg2;
55511   if (!arg2) {
55512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
55513     return 0;
55514   }
55515   {
55516     try {
55517       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
55518     } catch (std::out_of_range& e) {
55519       {
55520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55521       };
55522     } catch (std::exception& e) {
55523       {
55524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55525       };
55526     } catch (...) {
55527       {
55528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55529       };
55530     }
55531   }
55532   jresult = result;
55533   return jresult;
55534 }
55535
55536
55537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
55538   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55539   int arg2 ;
55540   SwigDirector_ViewImpl *darg = 0;
55541
55542   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55543   arg2 = (int)jarg2;
55544   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55545   {
55546     try {
55547       (darg)->OnStageConnection(arg2);
55548     } catch (std::out_of_range& e) {
55549       {
55550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55551       };
55552     } catch (std::exception& e) {
55553       {
55554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55555       };
55556     } catch (...) {
55557       {
55558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55559       };
55560     }
55561   }
55562 }
55563
55564
55565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
55566   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55567   int arg2 ;
55568   SwigDirector_ViewImpl *darg = 0;
55569
55570   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55571   arg2 = (int)jarg2;
55572   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55573   {
55574     try {
55575       (darg)->OnStageConnectionSwigPublic(arg2);
55576     } catch (std::out_of_range& e) {
55577       {
55578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55579       };
55580     } catch (std::exception& e) {
55581       {
55582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55583       };
55584     } catch (...) {
55585       {
55586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55587       };
55588     }
55589   }
55590 }
55591
55592
55593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
55594   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55595   SwigDirector_ViewImpl *darg = 0;
55596
55597   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55598   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55599   {
55600     try {
55601       (darg)->OnStageDisconnection();
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_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
55620   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55621   SwigDirector_ViewImpl *darg = 0;
55622
55623   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55624   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55625   {
55626     try {
55627       (darg)->OnStageDisconnectionSwigPublic();
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 void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
55646   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55647   Dali::Actor *arg2 = 0 ;
55648   SwigDirector_ViewImpl *darg = 0;
55649
55650   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55651   arg2 = (Dali::Actor *)jarg2;
55652   if (!arg2) {
55653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55654     return ;
55655   }
55656   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55657   {
55658     try {
55659       (darg)->OnChildAdd(*arg2);
55660     } catch (std::out_of_range& e) {
55661       {
55662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55663       };
55664     } catch (std::exception& e) {
55665       {
55666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55667       };
55668     } catch (...) {
55669       {
55670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55671       };
55672     }
55673   }
55674 }
55675
55676
55677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
55678   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55679   Dali::Actor *arg2 = 0 ;
55680   SwigDirector_ViewImpl *darg = 0;
55681
55682   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55683   arg2 = (Dali::Actor *)jarg2;
55684   if (!arg2) {
55685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55686     return ;
55687   }
55688   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55689   {
55690     try {
55691       (darg)->OnChildAddSwigPublic(*arg2);
55692     } catch (std::out_of_range& e) {
55693       {
55694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55695       };
55696     } catch (std::exception& e) {
55697       {
55698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55699       };
55700     } catch (...) {
55701       {
55702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55703       };
55704     }
55705   }
55706 }
55707
55708
55709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
55710   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55711   Dali::Actor *arg2 = 0 ;
55712   SwigDirector_ViewImpl *darg = 0;
55713
55714   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55715   arg2 = (Dali::Actor *)jarg2;
55716   if (!arg2) {
55717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55718     return ;
55719   }
55720   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55721   {
55722     try {
55723       (darg)->OnChildRemove(*arg2);
55724     } catch (std::out_of_range& e) {
55725       {
55726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55727       };
55728     } catch (std::exception& e) {
55729       {
55730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55731       };
55732     } catch (...) {
55733       {
55734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55735       };
55736     }
55737   }
55738 }
55739
55740
55741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
55742   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55743   Dali::Actor *arg2 = 0 ;
55744   SwigDirector_ViewImpl *darg = 0;
55745
55746   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55747   arg2 = (Dali::Actor *)jarg2;
55748   if (!arg2) {
55749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55750     return ;
55751   }
55752   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55753   {
55754     try {
55755       (darg)->OnChildRemoveSwigPublic(*arg2);
55756     } catch (std::out_of_range& e) {
55757       {
55758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55759       };
55760     } catch (std::exception& e) {
55761       {
55762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55763       };
55764     } catch (...) {
55765       {
55766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55767       };
55768     }
55769   }
55770 }
55771
55772
55773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
55774   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55775   Dali::Property::Index arg2 ;
55776   Dali::Property::Value arg3 ;
55777   Dali::Property::Value *argp3 ;
55778   SwigDirector_ViewImpl *darg = 0;
55779
55780   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55781   arg2 = (Dali::Property::Index)jarg2;
55782   argp3 = (Dali::Property::Value *)jarg3;
55783   if (!argp3) {
55784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
55785     return ;
55786   }
55787   arg3 = *argp3;
55788   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55789   {
55790     try {
55791       (darg)->OnPropertySet(arg2,arg3);
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_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
55810   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55811   Dali::Property::Index arg2 ;
55812   Dali::Property::Value arg3 ;
55813   Dali::Property::Value *argp3 ;
55814   SwigDirector_ViewImpl *darg = 0;
55815
55816   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55817   arg2 = (Dali::Property::Index)jarg2;
55818   argp3 = (Dali::Property::Value *)jarg3;
55819   if (!argp3) {
55820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
55821     return ;
55822   }
55823   arg3 = *argp3;
55824   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55825   {
55826     try {
55827       (darg)->OnPropertySetSwigPublic(arg2,arg3);
55828     } catch (std::out_of_range& e) {
55829       {
55830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55831       };
55832     } catch (std::exception& e) {
55833       {
55834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55835       };
55836     } catch (...) {
55837       {
55838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55839       };
55840     }
55841   }
55842 }
55843
55844
55845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
55846   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55847   Dali::Vector3 *arg2 = 0 ;
55848   SwigDirector_ViewImpl *darg = 0;
55849
55850   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55851   arg2 = (Dali::Vector3 *)jarg2;
55852   if (!arg2) {
55853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55854     return ;
55855   }
55856   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55857   {
55858     try {
55859       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
55860     } catch (std::out_of_range& e) {
55861       {
55862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55863       };
55864     } catch (std::exception& e) {
55865       {
55866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55867       };
55868     } catch (...) {
55869       {
55870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55871       };
55872     }
55873   }
55874 }
55875
55876
55877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
55878   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55879   Dali::Vector3 *arg2 = 0 ;
55880   SwigDirector_ViewImpl *darg = 0;
55881
55882   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55883   arg2 = (Dali::Vector3 *)jarg2;
55884   if (!arg2) {
55885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55886     return ;
55887   }
55888   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55889   {
55890     try {
55891       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
55892     } catch (std::out_of_range& e) {
55893       {
55894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55895       };
55896     } catch (std::exception& e) {
55897       {
55898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55899       };
55900     } catch (...) {
55901       {
55902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55903       };
55904     }
55905   }
55906 }
55907
55908
55909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
55910   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55911   Dali::Animation *arg2 = 0 ;
55912   Dali::Vector3 *arg3 = 0 ;
55913   SwigDirector_ViewImpl *darg = 0;
55914
55915   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55916   arg2 = (Dali::Animation *)jarg2;
55917   if (!arg2) {
55918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
55919     return ;
55920   }
55921   arg3 = (Dali::Vector3 *)jarg3;
55922   if (!arg3) {
55923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55924     return ;
55925   }
55926   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55927   {
55928     try {
55929       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
55930     } catch (std::out_of_range& e) {
55931       {
55932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55933       };
55934     } catch (std::exception& e) {
55935       {
55936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55937       };
55938     } catch (...) {
55939       {
55940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55941       };
55942     }
55943   }
55944 }
55945
55946
55947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
55948   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55949   Dali::Animation *arg2 = 0 ;
55950   Dali::Vector3 *arg3 = 0 ;
55951   SwigDirector_ViewImpl *darg = 0;
55952
55953   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55954   arg2 = (Dali::Animation *)jarg2;
55955   if (!arg2) {
55956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
55957     return ;
55958   }
55959   arg3 = (Dali::Vector3 *)jarg3;
55960   if (!arg3) {
55961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55962     return ;
55963   }
55964   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55965   {
55966     try {
55967       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
55968     } catch (std::out_of_range& e) {
55969       {
55970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55971       };
55972     } catch (std::exception& e) {
55973       {
55974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55975       };
55976     } catch (...) {
55977       {
55978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55979       };
55980     }
55981   }
55982 }
55983
55984
55985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
55986   unsigned int jresult ;
55987   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55988   Dali::TouchEvent *arg2 = 0 ;
55989   SwigDirector_ViewImpl *darg = 0;
55990   bool result;
55991
55992   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55993   arg2 = (Dali::TouchEvent *)jarg2;
55994   if (!arg2) {
55995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
55996     return 0;
55997   }
55998   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55999   {
56000     try {
56001       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
56002     } catch (std::out_of_range& e) {
56003       {
56004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56005       };
56006     } catch (std::exception& e) {
56007       {
56008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56009       };
56010     } catch (...) {
56011       {
56012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56013       };
56014     }
56015   }
56016   jresult = result;
56017   return jresult;
56018 }
56019
56020
56021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56022   unsigned int jresult ;
56023   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56024   Dali::TouchEvent *arg2 = 0 ;
56025   SwigDirector_ViewImpl *darg = 0;
56026   bool result;
56027
56028   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56029   arg2 = (Dali::TouchEvent *)jarg2;
56030   if (!arg2) {
56031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
56032     return 0;
56033   }
56034   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56035   {
56036     try {
56037       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
56038     } catch (std::out_of_range& e) {
56039       {
56040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56041       };
56042     } catch (std::exception& e) {
56043       {
56044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56045       };
56046     } catch (...) {
56047       {
56048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56049       };
56050     }
56051   }
56052   jresult = result;
56053   return jresult;
56054 }
56055
56056
56057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
56058   unsigned int jresult ;
56059   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56060   Dali::HoverEvent *arg2 = 0 ;
56061   SwigDirector_ViewImpl *darg = 0;
56062   bool result;
56063
56064   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56065   arg2 = (Dali::HoverEvent *)jarg2;
56066   if (!arg2) {
56067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
56068     return 0;
56069   }
56070   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56071   {
56072     try {
56073       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
56074     } catch (std::out_of_range& e) {
56075       {
56076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56077       };
56078     } catch (std::exception& e) {
56079       {
56080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56081       };
56082     } catch (...) {
56083       {
56084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56085       };
56086     }
56087   }
56088   jresult = result;
56089   return jresult;
56090 }
56091
56092
56093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56094   unsigned int jresult ;
56095   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56096   Dali::HoverEvent *arg2 = 0 ;
56097   SwigDirector_ViewImpl *darg = 0;
56098   bool result;
56099
56100   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56101   arg2 = (Dali::HoverEvent *)jarg2;
56102   if (!arg2) {
56103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
56104     return 0;
56105   }
56106   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56107   {
56108     try {
56109       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
56110     } catch (std::out_of_range& e) {
56111       {
56112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56113       };
56114     } catch (std::exception& e) {
56115       {
56116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56117       };
56118     } catch (...) {
56119       {
56120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56121       };
56122     }
56123   }
56124   jresult = result;
56125   return jresult;
56126 }
56127
56128
56129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
56130   unsigned int jresult ;
56131   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56132   Dali::KeyEvent *arg2 = 0 ;
56133   SwigDirector_ViewImpl *darg = 0;
56134   bool result;
56135
56136   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56137   arg2 = (Dali::KeyEvent *)jarg2;
56138   if (!arg2) {
56139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56140     return 0;
56141   }
56142   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56143   {
56144     try {
56145       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
56146     } catch (std::out_of_range& e) {
56147       {
56148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56149       };
56150     } catch (std::exception& e) {
56151       {
56152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56153       };
56154     } catch (...) {
56155       {
56156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56157       };
56158     }
56159   }
56160   jresult = result;
56161   return jresult;
56162 }
56163
56164
56165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56166   unsigned int jresult ;
56167   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56168   Dali::KeyEvent *arg2 = 0 ;
56169   SwigDirector_ViewImpl *darg = 0;
56170   bool result;
56171
56172   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56173   arg2 = (Dali::KeyEvent *)jarg2;
56174   if (!arg2) {
56175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56176     return 0;
56177   }
56178   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56179   {
56180     try {
56181       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
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 = result;
56197   return jresult;
56198 }
56199
56200
56201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
56202   unsigned int jresult ;
56203   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56204   Dali::WheelEvent *arg2 = 0 ;
56205   SwigDirector_ViewImpl *darg = 0;
56206   bool result;
56207
56208   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56209   arg2 = (Dali::WheelEvent *)jarg2;
56210   if (!arg2) {
56211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56212     return 0;
56213   }
56214   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56215   {
56216     try {
56217       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
56218     } catch (std::out_of_range& e) {
56219       {
56220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56221       };
56222     } catch (std::exception& e) {
56223       {
56224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56225       };
56226     } catch (...) {
56227       {
56228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56229       };
56230     }
56231   }
56232   jresult = result;
56233   return jresult;
56234 }
56235
56236
56237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56238   unsigned int jresult ;
56239   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56240   Dali::WheelEvent *arg2 = 0 ;
56241   SwigDirector_ViewImpl *darg = 0;
56242   bool result;
56243
56244   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56245   arg2 = (Dali::WheelEvent *)jarg2;
56246   if (!arg2) {
56247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56248     return 0;
56249   }
56250   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56251   {
56252     try {
56253       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
56254     } catch (std::out_of_range& e) {
56255       {
56256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56257       };
56258     } catch (std::exception& e) {
56259       {
56260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56261       };
56262     } catch (...) {
56263       {
56264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56265       };
56266     }
56267   }
56268   jresult = result;
56269   return jresult;
56270 }
56271
56272
56273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
56274   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56275   Dali::Vector2 *arg2 = 0 ;
56276   Dali::RelayoutContainer *arg3 = 0 ;
56277   SwigDirector_ViewImpl *darg = 0;
56278
56279   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56280   arg2 = (Dali::Vector2 *)jarg2;
56281   if (!arg2) {
56282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
56283     return ;
56284   }
56285   arg3 = (Dali::RelayoutContainer *)jarg3;
56286   if (!arg3) {
56287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
56288     return ;
56289   }
56290   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56291   {
56292     try {
56293       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
56294     } catch (std::out_of_range& e) {
56295       {
56296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56297       };
56298     } catch (std::exception& e) {
56299       {
56300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56301       };
56302     } catch (...) {
56303       {
56304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56305       };
56306     }
56307   }
56308 }
56309
56310
56311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
56312   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56313   Dali::Vector2 *arg2 = 0 ;
56314   Dali::RelayoutContainer *arg3 = 0 ;
56315   SwigDirector_ViewImpl *darg = 0;
56316
56317   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56318   arg2 = (Dali::Vector2 *)jarg2;
56319   if (!arg2) {
56320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
56321     return ;
56322   }
56323   arg3 = (Dali::RelayoutContainer *)jarg3;
56324   if (!arg3) {
56325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
56326     return ;
56327   }
56328   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56329   {
56330     try {
56331       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
56332     } catch (std::out_of_range& e) {
56333       {
56334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56335       };
56336     } catch (std::exception& e) {
56337       {
56338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56339       };
56340     } catch (...) {
56341       {
56342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56343       };
56344     }
56345   }
56346 }
56347
56348
56349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
56350   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56351   Dali::ResizePolicy::Type arg2 ;
56352   Dali::Dimension::Type arg3 ;
56353   SwigDirector_ViewImpl *darg = 0;
56354
56355   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56356   arg2 = (Dali::ResizePolicy::Type)jarg2;
56357   arg3 = (Dali::Dimension::Type)jarg3;
56358   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56359   {
56360     try {
56361       (darg)->OnSetResizePolicy(arg2,arg3);
56362     } catch (std::out_of_range& e) {
56363       {
56364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56365       };
56366     } catch (std::exception& e) {
56367       {
56368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56369       };
56370     } catch (...) {
56371       {
56372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56373       };
56374     }
56375   }
56376 }
56377
56378
56379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
56380   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56381   Dali::ResizePolicy::Type arg2 ;
56382   Dali::Dimension::Type arg3 ;
56383   SwigDirector_ViewImpl *darg = 0;
56384
56385   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56386   arg2 = (Dali::ResizePolicy::Type)jarg2;
56387   arg3 = (Dali::Dimension::Type)jarg3;
56388   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56389   {
56390     try {
56391       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
56392     } catch (std::out_of_range& e) {
56393       {
56394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56395       };
56396     } catch (std::exception& e) {
56397       {
56398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56399       };
56400     } catch (...) {
56401       {
56402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56403       };
56404     }
56405   }
56406 }
56407
56408
56409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
56410   void * jresult ;
56411   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56412   SwigDirector_ViewImpl *darg = 0;
56413   Dali::Vector3 result;
56414
56415   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56416   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56417   {
56418     try {
56419       result = (darg)->GetNaturalSize();
56420     } catch (std::out_of_range& e) {
56421       {
56422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56423       };
56424     } catch (std::exception& e) {
56425       {
56426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56427       };
56428     } catch (...) {
56429       {
56430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56431       };
56432     }
56433   }
56434   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
56435   return jresult;
56436 }
56437
56438
56439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
56440   void * jresult ;
56441   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56442   SwigDirector_ViewImpl *darg = 0;
56443   Dali::Vector3 result;
56444
56445   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56446   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56447   {
56448     try {
56449       result = (darg)->GetNaturalSizeSwigPublic();
56450     } catch (std::out_of_range& e) {
56451       {
56452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56453       };
56454     } catch (std::exception& e) {
56455       {
56456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56457       };
56458     } catch (...) {
56459       {
56460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56461       };
56462     }
56463   }
56464   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
56465   return jresult;
56466 }
56467
56468
56469 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
56470   float jresult ;
56471   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56472   Dali::Actor *arg2 = 0 ;
56473   Dali::Dimension::Type arg3 ;
56474   SwigDirector_ViewImpl *darg = 0;
56475   float result;
56476
56477   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56478   arg2 = (Dali::Actor *)jarg2;
56479   if (!arg2) {
56480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
56481     return 0;
56482   }
56483   arg3 = (Dali::Dimension::Type)jarg3;
56484   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56485   {
56486     try {
56487       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
56488     } catch (std::out_of_range& e) {
56489       {
56490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56491       };
56492     } catch (std::exception& e) {
56493       {
56494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56495       };
56496     } catch (...) {
56497       {
56498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56499       };
56500     }
56501   }
56502   jresult = result;
56503   return jresult;
56504 }
56505
56506
56507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
56508   float jresult ;
56509   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56510   Dali::Actor *arg2 = 0 ;
56511   Dali::Dimension::Type arg3 ;
56512   SwigDirector_ViewImpl *darg = 0;
56513   float result;
56514
56515   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56516   arg2 = (Dali::Actor *)jarg2;
56517   if (!arg2) {
56518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
56519     return 0;
56520   }
56521   arg3 = (Dali::Dimension::Type)jarg3;
56522   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56523   {
56524     try {
56525       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
56526     } catch (std::out_of_range& e) {
56527       {
56528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56529       };
56530     } catch (std::exception& e) {
56531       {
56532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56533       };
56534     } catch (...) {
56535       {
56536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56537       };
56538     }
56539   }
56540   jresult = result;
56541   return jresult;
56542 }
56543
56544
56545 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
56546   float jresult ;
56547   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56548   float arg2 ;
56549   SwigDirector_ViewImpl *darg = 0;
56550   float result;
56551
56552   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56553   arg2 = (float)jarg2;
56554   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56555   {
56556     try {
56557       result = (float)(darg)->GetHeightForWidth(arg2);
56558     } catch (std::out_of_range& e) {
56559       {
56560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56561       };
56562     } catch (std::exception& e) {
56563       {
56564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56565       };
56566     } catch (...) {
56567       {
56568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56569       };
56570     }
56571   }
56572   jresult = result;
56573   return jresult;
56574 }
56575
56576
56577 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
56578   float jresult ;
56579   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56580   float arg2 ;
56581   SwigDirector_ViewImpl *darg = 0;
56582   float result;
56583
56584   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56585   arg2 = (float)jarg2;
56586   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56587   {
56588     try {
56589       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
56590     } catch (std::out_of_range& e) {
56591       {
56592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56593       };
56594     } catch (std::exception& e) {
56595       {
56596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56597       };
56598     } catch (...) {
56599       {
56600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56601       };
56602     }
56603   }
56604   jresult = result;
56605   return jresult;
56606 }
56607
56608
56609 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
56610   float jresult ;
56611   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56612   float arg2 ;
56613   SwigDirector_ViewImpl *darg = 0;
56614   float result;
56615
56616   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56617   arg2 = (float)jarg2;
56618   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56619   {
56620     try {
56621       result = (float)(darg)->GetWidthForHeight(arg2);
56622     } catch (std::out_of_range& e) {
56623       {
56624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56625       };
56626     } catch (std::exception& e) {
56627       {
56628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56629       };
56630     } catch (...) {
56631       {
56632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56633       };
56634     }
56635   }
56636   jresult = result;
56637   return jresult;
56638 }
56639
56640
56641 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
56642   float jresult ;
56643   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56644   float arg2 ;
56645   SwigDirector_ViewImpl *darg = 0;
56646   float result;
56647
56648   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56649   arg2 = (float)jarg2;
56650   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56651   {
56652     try {
56653       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
56654     } catch (std::out_of_range& e) {
56655       {
56656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56657       };
56658     } catch (std::exception& e) {
56659       {
56660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56661       };
56662     } catch (...) {
56663       {
56664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56665       };
56666     }
56667   }
56668   jresult = result;
56669   return jresult;
56670 }
56671
56672
56673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
56674   unsigned int jresult ;
56675   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56676   Dali::Dimension::Type arg2 ;
56677   SwigDirector_ViewImpl *darg = 0;
56678   bool result;
56679
56680   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56681   arg2 = (Dali::Dimension::Type)jarg2;
56682   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56683   {
56684     try {
56685       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
56686     } catch (std::out_of_range& e) {
56687       {
56688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56689       };
56690     } catch (std::exception& e) {
56691       {
56692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56693       };
56694     } catch (...) {
56695       {
56696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56697       };
56698     }
56699   }
56700   jresult = result;
56701   return jresult;
56702 }
56703
56704
56705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
56706   unsigned int jresult ;
56707   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56708   Dali::Dimension::Type arg2 ;
56709   SwigDirector_ViewImpl *darg = 0;
56710   bool result;
56711
56712   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56713   arg2 = (Dali::Dimension::Type)jarg2;
56714   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56715   {
56716     try {
56717       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
56718     } catch (std::out_of_range& e) {
56719       {
56720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56721       };
56722     } catch (std::exception& e) {
56723       {
56724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56725       };
56726     } catch (...) {
56727       {
56728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56729       };
56730     }
56731   }
56732   jresult = result;
56733   return jresult;
56734 }
56735
56736
56737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
56738   unsigned int jresult ;
56739   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56740   SwigDirector_ViewImpl *darg = 0;
56741   bool result;
56742
56743   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56744   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56745   {
56746     try {
56747       result = (bool)(darg)->RelayoutDependentOnChildren();
56748     } catch (std::out_of_range& e) {
56749       {
56750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56751       };
56752     } catch (std::exception& e) {
56753       {
56754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56755       };
56756     } catch (...) {
56757       {
56758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56759       };
56760     }
56761   }
56762   jresult = result;
56763   return jresult;
56764 }
56765
56766
56767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
56768   unsigned int jresult ;
56769   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56770   SwigDirector_ViewImpl *darg = 0;
56771   bool result;
56772
56773   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56774   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56775   {
56776     try {
56777       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
56778     } catch (std::out_of_range& e) {
56779       {
56780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56781       };
56782     } catch (std::exception& e) {
56783       {
56784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56785       };
56786     } catch (...) {
56787       {
56788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56789       };
56790     }
56791   }
56792   jresult = result;
56793   return jresult;
56794 }
56795
56796
56797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
56798   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56799   Dali::Dimension::Type arg2 ;
56800   SwigDirector_ViewImpl *darg = 0;
56801
56802   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56803   arg2 = (Dali::Dimension::Type)jarg2;
56804   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56805   {
56806     try {
56807       (darg)->OnCalculateRelayoutSize(arg2);
56808     } catch (std::out_of_range& e) {
56809       {
56810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56811       };
56812     } catch (std::exception& e) {
56813       {
56814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56815       };
56816     } catch (...) {
56817       {
56818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56819       };
56820     }
56821   }
56822 }
56823
56824
56825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
56826   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56827   Dali::Dimension::Type arg2 ;
56828   SwigDirector_ViewImpl *darg = 0;
56829
56830   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56831   arg2 = (Dali::Dimension::Type)jarg2;
56832   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56833   {
56834     try {
56835       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
56836     } catch (std::out_of_range& e) {
56837       {
56838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56839       };
56840     } catch (std::exception& e) {
56841       {
56842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56843       };
56844     } catch (...) {
56845       {
56846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56847       };
56848     }
56849   }
56850 }
56851
56852
56853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
56854   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56855   float arg2 ;
56856   Dali::Dimension::Type arg3 ;
56857   SwigDirector_ViewImpl *darg = 0;
56858
56859   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56860   arg2 = (float)jarg2;
56861   arg3 = (Dali::Dimension::Type)jarg3;
56862   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56863   {
56864     try {
56865       (darg)->OnLayoutNegotiated(arg2,arg3);
56866     } catch (std::out_of_range& e) {
56867       {
56868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56869       };
56870     } catch (std::exception& e) {
56871       {
56872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56873       };
56874     } catch (...) {
56875       {
56876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56877       };
56878     }
56879   }
56880 }
56881
56882
56883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
56884   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56885   float arg2 ;
56886   Dali::Dimension::Type arg3 ;
56887   SwigDirector_ViewImpl *darg = 0;
56888
56889   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56890   arg2 = (float)jarg2;
56891   arg3 = (Dali::Dimension::Type)jarg3;
56892   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56893   {
56894     try {
56895       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
56896     } catch (std::out_of_range& e) {
56897       {
56898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56899       };
56900     } catch (std::exception& e) {
56901       {
56902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56903       };
56904     } catch (...) {
56905       {
56906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56907       };
56908     }
56909   }
56910 }
56911
56912
56913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
56914   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56915
56916   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56917   {
56918     try {
56919       (arg1)->OnInitialize();
56920     } catch (std::out_of_range& e) {
56921       {
56922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56923       };
56924     } catch (std::exception& e) {
56925       {
56926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56927       };
56928     } catch (...) {
56929       {
56930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56931       };
56932     }
56933   }
56934 }
56935
56936
56937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
56938   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56939
56940   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56941   {
56942     try {
56943       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
56944     } catch (std::out_of_range& e) {
56945       {
56946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56947       };
56948     } catch (std::exception& e) {
56949       {
56950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56951       };
56952     } catch (...) {
56953       {
56954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56955       };
56956     }
56957   }
56958 }
56959
56960
56961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
56962   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56963   Dali::Actor *arg2 = 0 ;
56964
56965   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56966   arg2 = (Dali::Actor *)jarg2;
56967   if (!arg2) {
56968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
56969     return ;
56970   }
56971   {
56972     try {
56973       (arg1)->OnControlChildAdd(*arg2);
56974     } catch (std::out_of_range& e) {
56975       {
56976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56977       };
56978     } catch (std::exception& e) {
56979       {
56980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56981       };
56982     } catch (...) {
56983       {
56984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56985       };
56986     }
56987   }
56988 }
56989
56990
56991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56992   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56993   Dali::Actor *arg2 = 0 ;
56994
56995   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56996   arg2 = (Dali::Actor *)jarg2;
56997   if (!arg2) {
56998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
56999     return ;
57000   }
57001   {
57002     try {
57003       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
57004     } catch (std::out_of_range& e) {
57005       {
57006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57007       };
57008     } catch (std::exception& e) {
57009       {
57010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57011       };
57012     } catch (...) {
57013       {
57014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57015       };
57016     }
57017   }
57018 }
57019
57020
57021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
57022   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57023   Dali::Actor *arg2 = 0 ;
57024
57025   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57026   arg2 = (Dali::Actor *)jarg2;
57027   if (!arg2) {
57028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57029     return ;
57030   }
57031   {
57032     try {
57033       (arg1)->OnControlChildRemove(*arg2);
57034     } catch (std::out_of_range& e) {
57035       {
57036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57037       };
57038     } catch (std::exception& e) {
57039       {
57040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57041       };
57042     } catch (...) {
57043       {
57044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57045       };
57046     }
57047   }
57048 }
57049
57050
57051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57052   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57053   Dali::Actor *arg2 = 0 ;
57054
57055   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57056   arg2 = (Dali::Actor *)jarg2;
57057   if (!arg2) {
57058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57059     return ;
57060   }
57061   {
57062     try {
57063       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
57064     } catch (std::out_of_range& e) {
57065       {
57066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57067       };
57068     } catch (std::exception& e) {
57069       {
57070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57071       };
57072     } catch (...) {
57073       {
57074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57075       };
57076     }
57077   }
57078 }
57079
57080
57081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
57082   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57083   Dali::Toolkit::StyleManager arg2 ;
57084   Dali::StyleChange::Type arg3 ;
57085   Dali::Toolkit::StyleManager *argp2 ;
57086
57087   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57088   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
57089   if (!argp2) {
57090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
57091     return ;
57092   }
57093   arg2 = *argp2;
57094   arg3 = (Dali::StyleChange::Type)jarg3;
57095   {
57096     try {
57097       (arg1)->OnStyleChange(arg2,arg3);
57098     } catch (std::out_of_range& e) {
57099       {
57100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57101       };
57102     } catch (std::exception& e) {
57103       {
57104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57105       };
57106     } catch (...) {
57107       {
57108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57109       };
57110     }
57111   }
57112 }
57113
57114
57115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
57116   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57117   Dali::Toolkit::StyleManager arg2 ;
57118   Dali::StyleChange::Type arg3 ;
57119   Dali::Toolkit::StyleManager *argp2 ;
57120
57121   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57122   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
57123   if (!argp2) {
57124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
57125     return ;
57126   }
57127   arg2 = *argp2;
57128   arg3 = (Dali::StyleChange::Type)jarg3;
57129   {
57130     try {
57131       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
57132     } catch (std::out_of_range& e) {
57133       {
57134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57135       };
57136     } catch (std::exception& e) {
57137       {
57138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57139       };
57140     } catch (...) {
57141       {
57142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57143       };
57144     }
57145   }
57146 }
57147
57148
57149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
57150   unsigned int jresult ;
57151   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57152   bool result;
57153
57154   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57155   {
57156     try {
57157       result = (bool)(arg1)->OnAccessibilityActivated();
57158     } catch (std::out_of_range& e) {
57159       {
57160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57161       };
57162     } catch (std::exception& e) {
57163       {
57164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57165       };
57166     } catch (...) {
57167       {
57168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57169       };
57170     }
57171   }
57172   jresult = result;
57173   return jresult;
57174 }
57175
57176
57177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
57178   unsigned int jresult ;
57179   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57180   bool result;
57181
57182   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57183   {
57184     try {
57185       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
57186     } catch (std::out_of_range& e) {
57187       {
57188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57189       };
57190     } catch (std::exception& e) {
57191       {
57192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57193       };
57194     } catch (...) {
57195       {
57196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57197       };
57198     }
57199   }
57200   jresult = result;
57201   return jresult;
57202 }
57203
57204
57205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
57206   unsigned int jresult ;
57207   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57208   Dali::PanGesture arg2 ;
57209   Dali::PanGesture *argp2 ;
57210   bool result;
57211
57212   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57213   argp2 = (Dali::PanGesture *)jarg2;
57214   if (!argp2) {
57215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
57216     return 0;
57217   }
57218   arg2 = *argp2;
57219   {
57220     try {
57221       result = (bool)(arg1)->OnAccessibilityPan(arg2);
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 = result;
57237   return jresult;
57238 }
57239
57240
57241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57242   unsigned int jresult ;
57243   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57244   Dali::PanGesture arg2 ;
57245   Dali::PanGesture *argp2 ;
57246   bool result;
57247
57248   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57249   argp2 = (Dali::PanGesture *)jarg2;
57250   if (!argp2) {
57251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
57252     return 0;
57253   }
57254   arg2 = *argp2;
57255   {
57256     try {
57257       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
57258     } catch (std::out_of_range& e) {
57259       {
57260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57261       };
57262     } catch (std::exception& e) {
57263       {
57264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57265       };
57266     } catch (...) {
57267       {
57268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57269       };
57270     }
57271   }
57272   jresult = result;
57273   return jresult;
57274 }
57275
57276
57277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
57278   unsigned int jresult ;
57279   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57280   Dali::TouchEvent *arg2 = 0 ;
57281   bool result;
57282
57283   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57284   arg2 = (Dali::TouchEvent *)jarg2;
57285   if (!arg2) {
57286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
57287     return 0;
57288   }
57289   {
57290     try {
57291       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
57292     } catch (std::out_of_range& e) {
57293       {
57294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57295       };
57296     } catch (std::exception& e) {
57297       {
57298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57299       };
57300     } catch (...) {
57301       {
57302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57303       };
57304     }
57305   }
57306   jresult = result;
57307   return jresult;
57308 }
57309
57310
57311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57312   unsigned int jresult ;
57313   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57314   Dali::TouchEvent *arg2 = 0 ;
57315   bool result;
57316
57317   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57318   arg2 = (Dali::TouchEvent *)jarg2;
57319   if (!arg2) {
57320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
57321     return 0;
57322   }
57323   {
57324     try {
57325       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
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 = result;
57341   return jresult;
57342 }
57343
57344
57345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
57346   unsigned int jresult ;
57347   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57348   bool arg2 ;
57349   bool result;
57350
57351   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57352   arg2 = jarg2 ? true : false;
57353   {
57354     try {
57355       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
57356     } catch (std::out_of_range& e) {
57357       {
57358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57359       };
57360     } catch (std::exception& e) {
57361       {
57362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57363       };
57364     } catch (...) {
57365       {
57366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57367       };
57368     }
57369   }
57370   jresult = result;
57371   return jresult;
57372 }
57373
57374
57375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
57376   unsigned int jresult ;
57377   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57378   bool arg2 ;
57379   bool result;
57380
57381   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57382   arg2 = jarg2 ? true : false;
57383   {
57384     try {
57385       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
57386     } catch (std::out_of_range& e) {
57387       {
57388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57389       };
57390     } catch (std::exception& e) {
57391       {
57392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57393       };
57394     } catch (...) {
57395       {
57396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57397       };
57398     }
57399   }
57400   jresult = result;
57401   return jresult;
57402 }
57403
57404
57405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
57406   unsigned int jresult ;
57407   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57408   bool result;
57409
57410   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57411   {
57412     try {
57413       result = (bool)(arg1)->OnAccessibilityZoom();
57414     } catch (std::out_of_range& e) {
57415       {
57416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57417       };
57418     } catch (std::exception& e) {
57419       {
57420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57421       };
57422     } catch (...) {
57423       {
57424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57425       };
57426     }
57427   }
57428   jresult = result;
57429   return jresult;
57430 }
57431
57432
57433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
57434   unsigned int jresult ;
57435   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57436   bool result;
57437
57438   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57439   {
57440     try {
57441       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
57442     } catch (std::out_of_range& e) {
57443       {
57444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57445       };
57446     } catch (std::exception& e) {
57447       {
57448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57449       };
57450     } catch (...) {
57451       {
57452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57453       };
57454     }
57455   }
57456   jresult = result;
57457   return jresult;
57458 }
57459
57460
57461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
57462   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57463
57464   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57465   {
57466     try {
57467       (arg1)->OnKeyInputFocusGained();
57468     } catch (std::out_of_range& e) {
57469       {
57470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57471       };
57472     } catch (std::exception& e) {
57473       {
57474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57475       };
57476     } catch (...) {
57477       {
57478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57479       };
57480     }
57481   }
57482 }
57483
57484
57485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
57486   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57487
57488   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57489   {
57490     try {
57491       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
57492     } catch (std::out_of_range& e) {
57493       {
57494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57495       };
57496     } catch (std::exception& e) {
57497       {
57498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57499       };
57500     } catch (...) {
57501       {
57502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57503       };
57504     }
57505   }
57506 }
57507
57508
57509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
57510   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57511
57512   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57513   {
57514     try {
57515       (arg1)->OnKeyInputFocusLost();
57516     } catch (std::out_of_range& e) {
57517       {
57518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57519       };
57520     } catch (std::exception& e) {
57521       {
57522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57523       };
57524     } catch (...) {
57525       {
57526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57527       };
57528     }
57529   }
57530 }
57531
57532
57533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
57534   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57535
57536   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57537   {
57538     try {
57539       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
57540     } catch (std::out_of_range& e) {
57541       {
57542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57543       };
57544     } catch (std::exception& e) {
57545       {
57546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57547       };
57548     } catch (...) {
57549       {
57550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57551       };
57552     }
57553   }
57554 }
57555
57556
57557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
57558   void * jresult ;
57559   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57560   Dali::Actor arg2 ;
57561   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
57562   bool arg4 ;
57563   Dali::Actor *argp2 ;
57564   Dali::Actor result;
57565
57566   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57567   argp2 = (Dali::Actor *)jarg2;
57568   if (!argp2) {
57569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57570     return 0;
57571   }
57572   arg2 = *argp2;
57573   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
57574   arg4 = jarg4 ? true : false;
57575   {
57576     try {
57577       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
57578     } catch (std::out_of_range& e) {
57579       {
57580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57581       };
57582     } catch (std::exception& e) {
57583       {
57584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57585       };
57586     } catch (...) {
57587       {
57588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57589       };
57590     }
57591   }
57592   jresult = new Dali::Actor((const Dali::Actor &)result);
57593   return jresult;
57594 }
57595
57596
57597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
57598   void * jresult ;
57599   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57600   Dali::Actor arg2 ;
57601   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
57602   bool arg4 ;
57603   Dali::Actor *argp2 ;
57604   Dali::Actor result;
57605
57606   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57607   argp2 = (Dali::Actor *)jarg2;
57608   if (!argp2) {
57609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57610     return 0;
57611   }
57612   arg2 = *argp2;
57613   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
57614   arg4 = jarg4 ? true : false;
57615   {
57616     try {
57617       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
57618     } catch (std::out_of_range& e) {
57619       {
57620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57621       };
57622     } catch (std::exception& e) {
57623       {
57624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57625       };
57626     } catch (...) {
57627       {
57628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57629       };
57630     }
57631   }
57632   jresult = new Dali::Actor((const Dali::Actor &)result);
57633   return jresult;
57634 }
57635
57636
57637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
57638   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57639   Dali::Actor arg2 ;
57640   Dali::Actor *argp2 ;
57641
57642   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57643   argp2 = (Dali::Actor *)jarg2;
57644   if (!argp2) {
57645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57646     return ;
57647   }
57648   arg2 = *argp2;
57649   {
57650     try {
57651       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
57652     } catch (std::out_of_range& e) {
57653       {
57654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57655       };
57656     } catch (std::exception& e) {
57657       {
57658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57659       };
57660     } catch (...) {
57661       {
57662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57663       };
57664     }
57665   }
57666 }
57667
57668
57669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57670   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57671   Dali::Actor arg2 ;
57672   Dali::Actor *argp2 ;
57673
57674   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57675   argp2 = (Dali::Actor *)jarg2;
57676   if (!argp2) {
57677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57678     return ;
57679   }
57680   arg2 = *argp2;
57681   {
57682     try {
57683       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
57684     } catch (std::out_of_range& e) {
57685       {
57686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57687       };
57688     } catch (std::exception& e) {
57689       {
57690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57691       };
57692     } catch (...) {
57693       {
57694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57695       };
57696     }
57697   }
57698 }
57699
57700
57701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
57702   unsigned int jresult ;
57703   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57704   bool result;
57705
57706   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57707   {
57708     try {
57709       result = (bool)(arg1)->OnKeyboardEnter();
57710     } catch (std::out_of_range& e) {
57711       {
57712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57713       };
57714     } catch (std::exception& e) {
57715       {
57716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57717       };
57718     } catch (...) {
57719       {
57720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57721       };
57722     }
57723   }
57724   jresult = result;
57725   return jresult;
57726 }
57727
57728
57729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
57730   unsigned int jresult ;
57731   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57732   bool result;
57733
57734   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57735   {
57736     try {
57737       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
57738     } catch (std::out_of_range& e) {
57739       {
57740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57741       };
57742     } catch (std::exception& e) {
57743       {
57744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57745       };
57746     } catch (...) {
57747       {
57748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57749       };
57750     }
57751   }
57752   jresult = result;
57753   return jresult;
57754 }
57755
57756
57757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
57758   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57759   Dali::PinchGesture *arg2 = 0 ;
57760
57761   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57762   arg2 = (Dali::PinchGesture *)jarg2;
57763   if (!arg2) {
57764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57765     return ;
57766   }
57767   {
57768     try {
57769       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
57770     } catch (std::out_of_range& e) {
57771       {
57772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57773       };
57774     } catch (std::exception& e) {
57775       {
57776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57777       };
57778     } catch (...) {
57779       {
57780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57781       };
57782     }
57783   }
57784 }
57785
57786
57787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57788   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57789   Dali::PinchGesture *arg2 = 0 ;
57790
57791   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57792   arg2 = (Dali::PinchGesture *)jarg2;
57793   if (!arg2) {
57794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57795     return ;
57796   }
57797   {
57798     try {
57799       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
57800     } catch (std::out_of_range& e) {
57801       {
57802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57803       };
57804     } catch (std::exception& e) {
57805       {
57806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57807       };
57808     } catch (...) {
57809       {
57810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57811       };
57812     }
57813   }
57814 }
57815
57816
57817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
57818   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57819   Dali::PanGesture *arg2 = 0 ;
57820
57821   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57822   arg2 = (Dali::PanGesture *)jarg2;
57823   if (!arg2) {
57824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57825     return ;
57826   }
57827   {
57828     try {
57829       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
57830     } catch (std::out_of_range& e) {
57831       {
57832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57833       };
57834     } catch (std::exception& e) {
57835       {
57836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57837       };
57838     } catch (...) {
57839       {
57840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57841       };
57842     }
57843   }
57844 }
57845
57846
57847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57848   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57849   Dali::PanGesture *arg2 = 0 ;
57850
57851   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57852   arg2 = (Dali::PanGesture *)jarg2;
57853   if (!arg2) {
57854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57855     return ;
57856   }
57857   {
57858     try {
57859       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
57860     } catch (std::out_of_range& e) {
57861       {
57862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57863       };
57864     } catch (std::exception& e) {
57865       {
57866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57867       };
57868     } catch (...) {
57869       {
57870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57871       };
57872     }
57873   }
57874 }
57875
57876
57877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
57878   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57879   Dali::TapGesture *arg2 = 0 ;
57880
57881   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57882   arg2 = (Dali::TapGesture *)jarg2;
57883   if (!arg2) {
57884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57885     return ;
57886   }
57887   {
57888     try {
57889       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
57890     } catch (std::out_of_range& e) {
57891       {
57892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57893       };
57894     } catch (std::exception& e) {
57895       {
57896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57897       };
57898     } catch (...) {
57899       {
57900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57901       };
57902     }
57903   }
57904 }
57905
57906
57907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57908   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57909   Dali::TapGesture *arg2 = 0 ;
57910
57911   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57912   arg2 = (Dali::TapGesture *)jarg2;
57913   if (!arg2) {
57914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57915     return ;
57916   }
57917   {
57918     try {
57919       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
57920     } catch (std::out_of_range& e) {
57921       {
57922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57923       };
57924     } catch (std::exception& e) {
57925       {
57926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57927       };
57928     } catch (...) {
57929       {
57930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57931       };
57932     }
57933   }
57934 }
57935
57936
57937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
57938   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57939   Dali::LongPressGesture *arg2 = 0 ;
57940
57941   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57942   arg2 = (Dali::LongPressGesture *)jarg2;
57943   if (!arg2) {
57944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
57945     return ;
57946   }
57947   {
57948     try {
57949       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
57950     } catch (std::out_of_range& e) {
57951       {
57952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57953       };
57954     } catch (std::exception& e) {
57955       {
57956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57957       };
57958     } catch (...) {
57959       {
57960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57961       };
57962     }
57963   }
57964 }
57965
57966
57967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57968   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57969   Dali::LongPressGesture *arg2 = 0 ;
57970
57971   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57972   arg2 = (Dali::LongPressGesture *)jarg2;
57973   if (!arg2) {
57974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
57975     return ;
57976   }
57977   {
57978     try {
57979       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
57980     } catch (std::out_of_range& e) {
57981       {
57982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57983       };
57984     } catch (std::exception& e) {
57985       {
57986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57987       };
57988     } catch (...) {
57989       {
57990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57991       };
57992     }
57993   }
57994 }
57995
57996
57997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
57998   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57999   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58000   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58001
58002   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58003   arg2 = (Dali::SlotObserver *)jarg2;
58004   arg3 = (Dali::CallbackBase *)jarg3;
58005   {
58006     try {
58007       (arg1)->SignalConnected(arg2,arg3);
58008     } catch (std::out_of_range& e) {
58009       {
58010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58011       };
58012     } catch (std::exception& e) {
58013       {
58014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58015       };
58016     } catch (...) {
58017       {
58018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58019       };
58020     }
58021   }
58022 }
58023
58024
58025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
58026   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58027   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58028   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58029
58030   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58031   arg2 = (Dali::SlotObserver *)jarg2;
58032   arg3 = (Dali::CallbackBase *)jarg3;
58033   {
58034     try {
58035       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
58036     } catch (std::out_of_range& e) {
58037       {
58038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58039       };
58040     } catch (std::exception& e) {
58041       {
58042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58043       };
58044     } catch (...) {
58045       {
58046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58047       };
58048     }
58049   }
58050 }
58051
58052
58053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
58054   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58055   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58056   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58057
58058   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58059   arg2 = (Dali::SlotObserver *)jarg2;
58060   arg3 = (Dali::CallbackBase *)jarg3;
58061   {
58062     try {
58063       (arg1)->SignalDisconnected(arg2,arg3);
58064     } catch (std::out_of_range& e) {
58065       {
58066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58067       };
58068     } catch (std::exception& e) {
58069       {
58070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58071       };
58072     } catch (...) {
58073       {
58074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58075       };
58076     }
58077   }
58078 }
58079
58080
58081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
58082   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58083   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58084   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58085
58086   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58087   arg2 = (Dali::SlotObserver *)jarg2;
58088   arg3 = (Dali::CallbackBase *)jarg3;
58089   {
58090     try {
58091       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
58092     } catch (std::out_of_range& e) {
58093       {
58094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58095       };
58096     } catch (std::exception& e) {
58097       {
58098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58099       };
58100     } catch (...) {
58101       {
58102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58103       };
58104     }
58105   }
58106 }
58107
58108
58109 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) {
58110   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
58111   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
58112   if (director) {
58113     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);
58114   }
58115 }
58116
58117
58118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
58119   void * jresult ;
58120   Dali::Toolkit::Control *arg1 = 0 ;
58121   Dali::Toolkit::Internal::Control *result = 0 ;
58122
58123   arg1 = (Dali::Toolkit::Control *)jarg1;
58124   if (!arg1) {
58125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
58126     return 0;
58127   }
58128   {
58129     try {
58130       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
58131     } catch (std::out_of_range& e) {
58132       {
58133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58134       };
58135     } catch (std::exception& e) {
58136       {
58137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58138       };
58139     } catch (...) {
58140       {
58141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58142       };
58143     }
58144   }
58145   jresult = (void *)result;
58146   return jresult;
58147 }
58148
58149
58150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
58151   int jresult ;
58152   int result;
58153
58154   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
58155   jresult = (int)result;
58156   return jresult;
58157 }
58158
58159
58160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
58161   int jresult ;
58162   int result;
58163
58164   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
58165   jresult = (int)result;
58166   return jresult;
58167 }
58168
58169
58170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
58171   int jresult ;
58172   int result;
58173
58174   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
58175   jresult = (int)result;
58176   return jresult;
58177 }
58178
58179
58180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
58181   int jresult ;
58182   int result;
58183
58184   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
58185   jresult = (int)result;
58186   return jresult;
58187 }
58188
58189
58190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
58191   int jresult ;
58192   int result;
58193
58194   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
58195   jresult = (int)result;
58196   return jresult;
58197 }
58198
58199
58200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
58201   void * jresult ;
58202   Dali::Toolkit::Control::Property *result = 0 ;
58203
58204   {
58205     try {
58206       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
58207     } catch (std::out_of_range& e) {
58208       {
58209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58210       };
58211     } catch (std::exception& e) {
58212       {
58213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58214       };
58215     } catch (...) {
58216       {
58217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58218       };
58219     }
58220   }
58221   jresult = (void *)result;
58222   return jresult;
58223 }
58224
58225
58226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
58227   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
58228
58229   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
58230   {
58231     try {
58232       delete arg1;
58233     } catch (std::out_of_range& e) {
58234       {
58235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58236       };
58237     } catch (std::exception& e) {
58238       {
58239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58240       };
58241     } catch (...) {
58242       {
58243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58244       };
58245     }
58246   }
58247 }
58248
58249
58250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
58251   void * jresult ;
58252   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
58253
58254   {
58255     try {
58256       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
58257     } catch (std::out_of_range& e) {
58258       {
58259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58260       };
58261     } catch (std::exception& e) {
58262       {
58263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58264       };
58265     } catch (...) {
58266       {
58267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58268       };
58269     }
58270   }
58271   jresult = (void *)result;
58272   return jresult;
58273 }
58274
58275
58276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
58277   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
58278
58279   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
58280   {
58281     try {
58282       delete arg1;
58283     } catch (std::out_of_range& e) {
58284       {
58285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58286       };
58287     } catch (std::exception& e) {
58288       {
58289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58290       };
58291     } catch (...) {
58292       {
58293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58294       };
58295     }
58296   }
58297 }
58298
58299
58300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
58301   void * jresult ;
58302   Dali::Toolkit::Control result;
58303
58304   {
58305     try {
58306       result = Dali::Toolkit::Control::New();
58307     } catch (std::out_of_range& e) {
58308       {
58309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58310       };
58311     } catch (std::exception& e) {
58312       {
58313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58314       };
58315     } catch (...) {
58316       {
58317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58318       };
58319     }
58320   }
58321   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58322   return jresult;
58323 }
58324
58325
58326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
58327   void * jresult ;
58328   Dali::Toolkit::Control *result = 0 ;
58329
58330   {
58331     try {
58332       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
58333     } catch (std::out_of_range& e) {
58334       {
58335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58336       };
58337     } catch (std::exception& e) {
58338       {
58339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58340       };
58341     } catch (...) {
58342       {
58343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58344       };
58345     }
58346   }
58347   jresult = (void *)result;
58348   return jresult;
58349 }
58350
58351
58352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
58353   void * jresult ;
58354   Dali::Toolkit::Control *arg1 = 0 ;
58355   Dali::Toolkit::Control *result = 0 ;
58356
58357   arg1 = (Dali::Toolkit::Control *)jarg1;
58358   if (!arg1) {
58359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
58360     return 0;
58361   }
58362   {
58363     try {
58364       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
58365     } catch (std::out_of_range& e) {
58366       {
58367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58368       };
58369     } catch (std::exception& e) {
58370       {
58371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58372       };
58373     } catch (...) {
58374       {
58375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58376       };
58377     }
58378   }
58379   jresult = (void *)result;
58380   return jresult;
58381 }
58382
58383
58384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
58385   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58386
58387   arg1 = (Dali::Toolkit::Control *)jarg1;
58388   {
58389     try {
58390       delete arg1;
58391     } catch (std::out_of_range& e) {
58392       {
58393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58394       };
58395     } catch (std::exception& e) {
58396       {
58397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58398       };
58399     } catch (...) {
58400       {
58401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58402       };
58403     }
58404   }
58405 }
58406
58407
58408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
58409   void * jresult ;
58410   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58411   Dali::Toolkit::Control *arg2 = 0 ;
58412   Dali::Toolkit::Control *result = 0 ;
58413
58414   arg1 = (Dali::Toolkit::Control *)jarg1;
58415   arg2 = (Dali::Toolkit::Control *)jarg2;
58416   if (!arg2) {
58417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
58418     return 0;
58419   }
58420   {
58421     try {
58422       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
58423     } catch (std::out_of_range& e) {
58424       {
58425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58426       };
58427     } catch (std::exception& e) {
58428       {
58429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58430       };
58431     } catch (...) {
58432       {
58433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58434       };
58435     }
58436   }
58437   jresult = (void *)result;
58438   return jresult;
58439 }
58440
58441
58442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
58443   void * jresult ;
58444   Dali::BaseHandle arg1 ;
58445   Dali::BaseHandle *argp1 ;
58446   Dali::Toolkit::Control result;
58447
58448   argp1 = (Dali::BaseHandle *)jarg1;
58449   if (!argp1) {
58450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58451     return 0;
58452   }
58453   arg1 = *argp1;
58454   {
58455     try {
58456       result = Dali::Toolkit::Control::DownCast(arg1);
58457     } catch (std::out_of_range& e) {
58458       {
58459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58460       };
58461     } catch (std::exception& e) {
58462       {
58463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58464       };
58465     } catch (...) {
58466       {
58467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58468       };
58469     }
58470   }
58471   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58472   return jresult;
58473 }
58474
58475
58476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
58477   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58478
58479   arg1 = (Dali::Toolkit::Control *)jarg1;
58480   {
58481     try {
58482       (arg1)->SetKeyInputFocus();
58483     } catch (std::out_of_range& e) {
58484       {
58485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58486       };
58487     } catch (std::exception& e) {
58488       {
58489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58490       };
58491     } catch (...) {
58492       {
58493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58494       };
58495     }
58496   }
58497 }
58498
58499
58500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
58501   unsigned int jresult ;
58502   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58503   bool result;
58504
58505   arg1 = (Dali::Toolkit::Control *)jarg1;
58506   {
58507     try {
58508       result = (bool)(arg1)->HasKeyInputFocus();
58509     } catch (std::out_of_range& e) {
58510       {
58511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58512       };
58513     } catch (std::exception& e) {
58514       {
58515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58516       };
58517     } catch (...) {
58518       {
58519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58520       };
58521     }
58522   }
58523   jresult = result;
58524   return jresult;
58525 }
58526
58527
58528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
58529   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58530
58531   arg1 = (Dali::Toolkit::Control *)jarg1;
58532   {
58533     try {
58534       (arg1)->ClearKeyInputFocus();
58535     } catch (std::out_of_range& e) {
58536       {
58537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58538       };
58539     } catch (std::exception& e) {
58540       {
58541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58542       };
58543     } catch (...) {
58544       {
58545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58546       };
58547     }
58548   }
58549 }
58550
58551
58552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
58553   void * jresult ;
58554   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58555   Dali::PinchGestureDetector result;
58556
58557   arg1 = (Dali::Toolkit::Control *)jarg1;
58558   {
58559     try {
58560       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
58561     } catch (std::out_of_range& e) {
58562       {
58563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58564       };
58565     } catch (std::exception& e) {
58566       {
58567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58568       };
58569     } catch (...) {
58570       {
58571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58572       };
58573     }
58574   }
58575   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
58576   return jresult;
58577 }
58578
58579
58580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
58581   void * jresult ;
58582   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58583   Dali::PanGestureDetector result;
58584
58585   arg1 = (Dali::Toolkit::Control *)jarg1;
58586   {
58587     try {
58588       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
58589     } catch (std::out_of_range& e) {
58590       {
58591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58592       };
58593     } catch (std::exception& e) {
58594       {
58595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58596       };
58597     } catch (...) {
58598       {
58599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58600       };
58601     }
58602   }
58603   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
58604   return jresult;
58605 }
58606
58607
58608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
58609   void * jresult ;
58610   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58611   Dali::TapGestureDetector result;
58612
58613   arg1 = (Dali::Toolkit::Control *)jarg1;
58614   {
58615     try {
58616       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
58617     } catch (std::out_of_range& e) {
58618       {
58619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58620       };
58621     } catch (std::exception& e) {
58622       {
58623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58624       };
58625     } catch (...) {
58626       {
58627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58628       };
58629     }
58630   }
58631   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
58632   return jresult;
58633 }
58634
58635
58636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
58637   void * jresult ;
58638   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58639   Dali::LongPressGestureDetector result;
58640
58641   arg1 = (Dali::Toolkit::Control *)jarg1;
58642   {
58643     try {
58644       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
58645     } catch (std::out_of_range& e) {
58646       {
58647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58648       };
58649     } catch (std::exception& e) {
58650       {
58651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58652       };
58653     } catch (...) {
58654       {
58655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58656       };
58657     }
58658   }
58659   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
58660   return jresult;
58661 }
58662
58663
58664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
58665   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58666   std::string *arg2 = 0 ;
58667
58668   arg1 = (Dali::Toolkit::Control *)jarg1;
58669   if (!jarg2) {
58670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58671     return ;
58672   }
58673   std::string arg2_str(jarg2);
58674   arg2 = &arg2_str;
58675   {
58676     try {
58677       (arg1)->SetStyleName((std::string const &)*arg2);
58678     } catch (std::out_of_range& e) {
58679       {
58680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58681       };
58682     } catch (std::exception& e) {
58683       {
58684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58685       };
58686     } catch (...) {
58687       {
58688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58689       };
58690     }
58691   }
58692
58693   //argout typemap for const std::string&
58694
58695 }
58696
58697
58698 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
58699   char * jresult ;
58700   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58701   std::string *result = 0 ;
58702
58703   arg1 = (Dali::Toolkit::Control *)jarg1;
58704   {
58705     try {
58706       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
58707     } catch (std::out_of_range& e) {
58708       {
58709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58710       };
58711     } catch (std::exception& e) {
58712       {
58713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58714       };
58715     } catch (...) {
58716       {
58717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58718       };
58719     }
58720   }
58721   jresult = SWIG_csharp_string_callback(result->c_str());
58722   return jresult;
58723 }
58724
58725
58726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
58727   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58728   Dali::Vector4 *arg2 = 0 ;
58729
58730   arg1 = (Dali::Toolkit::Control *)jarg1;
58731   arg2 = (Dali::Vector4 *)jarg2;
58732   if (!arg2) {
58733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
58734     return ;
58735   }
58736   {
58737     try {
58738       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
58739     } catch (std::out_of_range& e) {
58740       {
58741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58742       };
58743     } catch (std::exception& e) {
58744       {
58745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58746       };
58747     } catch (...) {
58748       {
58749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58750       };
58751     }
58752   }
58753 }
58754
58755
58756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
58757   void * jresult ;
58758   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58759   Dali::Vector4 result;
58760
58761   arg1 = (Dali::Toolkit::Control *)jarg1;
58762   {
58763     try {
58764       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
58765     } catch (std::out_of_range& e) {
58766       {
58767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58768       };
58769     } catch (std::exception& e) {
58770       {
58771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58772       };
58773     } catch (...) {
58774       {
58775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58776       };
58777     }
58778   }
58779   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
58780   return jresult;
58781 }
58782
58783
58784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
58785   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58786   Dali::Image arg2 ;
58787   Dali::Image *argp2 ;
58788
58789   arg1 = (Dali::Toolkit::Control *)jarg1;
58790   argp2 = (Dali::Image *)jarg2;
58791   if (!argp2) {
58792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
58793     return ;
58794   }
58795   arg2 = *argp2;
58796   {
58797     try {
58798       (arg1)->SetBackgroundImage(arg2);
58799     } catch (std::out_of_range& e) {
58800       {
58801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58802       };
58803     } catch (std::exception& e) {
58804       {
58805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58806       };
58807     } catch (...) {
58808       {
58809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58810       };
58811     }
58812   }
58813 }
58814
58815
58816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
58817   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58818
58819   arg1 = (Dali::Toolkit::Control *)jarg1;
58820   {
58821     try {
58822       (arg1)->ClearBackground();
58823     } catch (std::out_of_range& e) {
58824       {
58825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58826       };
58827     } catch (std::exception& e) {
58828       {
58829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58830       };
58831     } catch (...) {
58832       {
58833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58834       };
58835     }
58836   }
58837 }
58838
58839
58840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
58841   void * jresult ;
58842   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58843   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
58844
58845   arg1 = (Dali::Toolkit::Control *)jarg1;
58846   {
58847     try {
58848       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
58849     } catch (std::out_of_range& e) {
58850       {
58851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58852       };
58853     } catch (std::exception& e) {
58854       {
58855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58856       };
58857     } catch (...) {
58858       {
58859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58860       };
58861     }
58862   }
58863   jresult = (void *)result;
58864   return jresult;
58865 }
58866
58867
58868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
58869   void * jresult ;
58870   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58871   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
58872
58873   arg1 = (Dali::Toolkit::Control *)jarg1;
58874   {
58875     try {
58876       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
58877     } catch (std::out_of_range& e) {
58878       {
58879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58880       };
58881     } catch (std::exception& e) {
58882       {
58883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58884       };
58885     } catch (...) {
58886       {
58887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58888       };
58889     }
58890   }
58891   jresult = (void *)result;
58892   return jresult;
58893 }
58894
58895
58896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
58897   void * jresult ;
58898   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58899   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
58900
58901   arg1 = (Dali::Toolkit::Control *)jarg1;
58902   {
58903     try {
58904       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
58905     } catch (std::out_of_range& e) {
58906       {
58907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58908       };
58909     } catch (std::exception& e) {
58910       {
58911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58912       };
58913     } catch (...) {
58914       {
58915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58916       };
58917     }
58918   }
58919   jresult = (void *)result;
58920   return jresult;
58921 }
58922
58923
58924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
58925   void * jresult ;
58926   Dali::Toolkit::Internal::Control *arg1 = 0 ;
58927   Dali::Toolkit::Control *result = 0 ;
58928
58929   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58930   if (!arg1) {
58931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
58932     return 0;
58933   }
58934   {
58935     try {
58936       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
58937     } catch (std::out_of_range& e) {
58938       {
58939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58940       };
58941     } catch (std::exception& e) {
58942       {
58943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58944       };
58945     } catch (...) {
58946       {
58947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58948       };
58949     }
58950   }
58951   jresult = (void *)result;
58952   return jresult;
58953 }
58954
58955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
58956 {
58957   void * jresult;
58958   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58959   arg1 = (Dali::Toolkit::Control *)jarg1;
58960
58961   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
58962
58963   Dali::Toolkit::TransitionData *arg2 = 0 ;
58964   Dali::Animation result;
58965
58966   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58967   if (!arg2) {
58968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58969     return 0;
58970   }
58971   {
58972     try {
58973       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
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 = new Dali::Animation((const Dali::Animation &)result);
58989   return jresult;
58990 }
58991
58992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
58993   void * jresult ;
58994   Dali::Toolkit::Control *arg1 = 0 ;
58995   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
58996
58997   arg1 = (Dali::Toolkit::Control *)jarg1;
58998   if (!arg1) {
58999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
59000     return 0;
59001   }
59002   {
59003     try {
59004       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
59005     } catch (std::out_of_range& e) {
59006       {
59007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59008       };
59009     } catch (std::exception& e) {
59010       {
59011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59012       };
59013     } catch (...) {
59014       {
59015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59016       };
59017     }
59018   }
59019   jresult = (void *)result;
59020   return jresult;
59021 }
59022
59023
59024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
59025   unsigned int jresult ;
59026   Dali::Toolkit::Control *arg1 = 0 ;
59027   bool result;
59028
59029   arg1 = (Dali::Toolkit::Control *)jarg1;
59030   if (!arg1) {
59031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
59032     return 0;
59033   }
59034   {
59035     try {
59036       result = (bool)arg1->IsResourceReady();
59037     } catch (std::out_of_range& e) {
59038       {
59039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59040       };
59041     } catch (std::exception& e) {
59042       {
59043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59044       };
59045     } catch (...) {
59046       {
59047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59048       };
59049     }
59050   }
59051   jresult = result;
59052   return jresult;
59053 }
59054
59055
59056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
59057   void * jresult ;
59058   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
59059
59060   {
59061     try {
59062       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
59063     } catch (std::out_of_range& e) {
59064       {
59065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59066       };
59067     } catch (std::exception& e) {
59068       {
59069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59070       };
59071     } catch (...) {
59072       {
59073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59074       };
59075     }
59076   }
59077   jresult = (void *)result;
59078   return jresult;
59079 }
59080
59081
59082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
59083   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59084
59085   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59086   {
59087     try {
59088       delete arg1;
59089     } catch (std::out_of_range& e) {
59090       {
59091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59092       };
59093     } catch (std::exception& e) {
59094       {
59095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59096       };
59097     } catch (...) {
59098       {
59099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59100       };
59101     }
59102   }
59103 }
59104
59105
59106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
59107   void * jresult ;
59108   Dali::Toolkit::KeyInputFocusManager result;
59109
59110   {
59111     try {
59112       result = Dali::Toolkit::KeyInputFocusManager::Get();
59113     } catch (std::out_of_range& e) {
59114       {
59115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59116       };
59117     } catch (std::exception& e) {
59118       {
59119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59120       };
59121     } catch (...) {
59122       {
59123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59124       };
59125     }
59126   }
59127   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
59128   return jresult;
59129 }
59130
59131
59132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
59133   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59134   Dali::Toolkit::Control arg2 ;
59135   Dali::Toolkit::Control *argp2 ;
59136
59137   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59138   argp2 = (Dali::Toolkit::Control *)jarg2;
59139   if (!argp2) {
59140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
59141     return ;
59142   }
59143   arg2 = *argp2;
59144   {
59145     try {
59146       (arg1)->SetFocus(arg2);
59147     } catch (std::out_of_range& e) {
59148       {
59149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59150       };
59151     } catch (std::exception& e) {
59152       {
59153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59154       };
59155     } catch (...) {
59156       {
59157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59158       };
59159     }
59160   }
59161 }
59162
59163
59164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
59165   void * jresult ;
59166   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59167   Dali::Toolkit::Control result;
59168
59169   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59170   {
59171     try {
59172       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
59173     } catch (std::out_of_range& e) {
59174       {
59175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59176       };
59177     } catch (std::exception& e) {
59178       {
59179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59180       };
59181     } catch (...) {
59182       {
59183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59184       };
59185     }
59186   }
59187   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59188   return jresult;
59189 }
59190
59191
59192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
59193   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59194   Dali::Toolkit::Control arg2 ;
59195   Dali::Toolkit::Control *argp2 ;
59196
59197   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59198   argp2 = (Dali::Toolkit::Control *)jarg2;
59199   if (!argp2) {
59200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
59201     return ;
59202   }
59203   arg2 = *argp2;
59204   {
59205     try {
59206       (arg1)->RemoveFocus(arg2);
59207     } catch (std::out_of_range& e) {
59208       {
59209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59210       };
59211     } catch (std::exception& e) {
59212       {
59213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59214       };
59215     } catch (...) {
59216       {
59217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59218       };
59219     }
59220   }
59221 }
59222
59223
59224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
59225   void * jresult ;
59226   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59227   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
59228
59229   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59230   {
59231     try {
59232       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
59233     } catch (std::out_of_range& e) {
59234       {
59235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59236       };
59237     } catch (std::exception& e) {
59238       {
59239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59240       };
59241     } catch (...) {
59242       {
59243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59244       };
59245     }
59246   }
59247   jresult = (void *)result;
59248   return jresult;
59249 }
59250
59251
59252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
59253   void * jresult ;
59254   Dali::Toolkit::Alignment::Padding *result = 0 ;
59255
59256   {
59257     try {
59258       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
59259     } catch (std::out_of_range& e) {
59260       {
59261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59262       };
59263     } catch (std::exception& e) {
59264       {
59265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59266       };
59267     } catch (...) {
59268       {
59269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59270       };
59271     }
59272   }
59273   jresult = (void *)result;
59274   return jresult;
59275 }
59276
59277
59278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
59279   void * jresult ;
59280   float arg1 ;
59281   float arg2 ;
59282   float arg3 ;
59283   float arg4 ;
59284   Dali::Toolkit::Alignment::Padding *result = 0 ;
59285
59286   arg1 = (float)jarg1;
59287   arg2 = (float)jarg2;
59288   arg3 = (float)jarg3;
59289   arg4 = (float)jarg4;
59290   {
59291     try {
59292       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
59293     } catch (std::out_of_range& e) {
59294       {
59295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59296       };
59297     } catch (std::exception& e) {
59298       {
59299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59300       };
59301     } catch (...) {
59302       {
59303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59304       };
59305     }
59306   }
59307   jresult = (void *)result;
59308   return jresult;
59309 }
59310
59311
59312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
59313   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59314   float arg2 ;
59315
59316   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59317   arg2 = (float)jarg2;
59318   if (arg1) (arg1)->left = arg2;
59319 }
59320
59321
59322 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
59323   float jresult ;
59324   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59325   float result;
59326
59327   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59328   result = (float) ((arg1)->left);
59329   jresult = result;
59330   return jresult;
59331 }
59332
59333
59334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
59335   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59336   float arg2 ;
59337
59338   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59339   arg2 = (float)jarg2;
59340   if (arg1) (arg1)->right = arg2;
59341 }
59342
59343
59344 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
59345   float jresult ;
59346   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59347   float result;
59348
59349   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59350   result = (float) ((arg1)->right);
59351   jresult = result;
59352   return jresult;
59353 }
59354
59355
59356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
59357   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59358   float arg2 ;
59359
59360   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59361   arg2 = (float)jarg2;
59362   if (arg1) (arg1)->top = arg2;
59363 }
59364
59365
59366 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
59367   float jresult ;
59368   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59369   float result;
59370
59371   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59372   result = (float) ((arg1)->top);
59373   jresult = result;
59374   return jresult;
59375 }
59376
59377
59378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
59379   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59380   float arg2 ;
59381
59382   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59383   arg2 = (float)jarg2;
59384   if (arg1) (arg1)->bottom = arg2;
59385 }
59386
59387
59388 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
59389   float jresult ;
59390   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59391   float result;
59392
59393   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59394   result = (float) ((arg1)->bottom);
59395   jresult = result;
59396   return jresult;
59397 }
59398
59399
59400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
59401   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59402
59403   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59404   {
59405     try {
59406       delete arg1;
59407     } catch (std::out_of_range& e) {
59408       {
59409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59410       };
59411     } catch (std::exception& e) {
59412       {
59413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59414       };
59415     } catch (...) {
59416       {
59417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59418       };
59419     }
59420   }
59421 }
59422
59423
59424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
59425   void * jresult ;
59426   Dali::Toolkit::Alignment *result = 0 ;
59427
59428   {
59429     try {
59430       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
59431     } catch (std::out_of_range& e) {
59432       {
59433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59434       };
59435     } catch (std::exception& e) {
59436       {
59437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59438       };
59439     } catch (...) {
59440       {
59441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59442       };
59443     }
59444   }
59445   jresult = (void *)result;
59446   return jresult;
59447 }
59448
59449
59450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
59451   void * jresult ;
59452   Dali::Toolkit::Alignment::Type arg1 ;
59453   Dali::Toolkit::Alignment::Type arg2 ;
59454   Dali::Toolkit::Alignment result;
59455
59456   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
59457   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
59458   {
59459     try {
59460       result = Dali::Toolkit::Alignment::New(arg1,arg2);
59461     } catch (std::out_of_range& e) {
59462       {
59463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59464       };
59465     } catch (std::exception& e) {
59466       {
59467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59468       };
59469     } catch (...) {
59470       {
59471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59472       };
59473     }
59474   }
59475   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59476   return jresult;
59477 }
59478
59479
59480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
59481   void * jresult ;
59482   Dali::Toolkit::Alignment::Type arg1 ;
59483   Dali::Toolkit::Alignment result;
59484
59485   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
59486   {
59487     try {
59488       result = Dali::Toolkit::Alignment::New(arg1);
59489     } catch (std::out_of_range& e) {
59490       {
59491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59492       };
59493     } catch (std::exception& e) {
59494       {
59495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59496       };
59497     } catch (...) {
59498       {
59499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59500       };
59501     }
59502   }
59503   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59504   return jresult;
59505 }
59506
59507
59508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
59509   void * jresult ;
59510   Dali::Toolkit::Alignment result;
59511
59512   {
59513     try {
59514       result = Dali::Toolkit::Alignment::New();
59515     } catch (std::out_of_range& e) {
59516       {
59517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59518       };
59519     } catch (std::exception& e) {
59520       {
59521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59522       };
59523     } catch (...) {
59524       {
59525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59526       };
59527     }
59528   }
59529   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59530   return jresult;
59531 }
59532
59533
59534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
59535   void * jresult ;
59536   Dali::Toolkit::Alignment *arg1 = 0 ;
59537   Dali::Toolkit::Alignment *result = 0 ;
59538
59539   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59540   if (!arg1) {
59541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
59542     return 0;
59543   }
59544   {
59545     try {
59546       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
59547     } catch (std::out_of_range& e) {
59548       {
59549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59550       };
59551     } catch (std::exception& e) {
59552       {
59553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59554       };
59555     } catch (...) {
59556       {
59557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59558       };
59559     }
59560   }
59561   jresult = (void *)result;
59562   return jresult;
59563 }
59564
59565
59566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
59567   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59568
59569   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59570   {
59571     try {
59572       delete arg1;
59573     } catch (std::out_of_range& e) {
59574       {
59575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59576       };
59577     } catch (std::exception& e) {
59578       {
59579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59580       };
59581     } catch (...) {
59582       {
59583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59584       };
59585     }
59586   }
59587 }
59588
59589
59590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
59591   void * jresult ;
59592   Dali::BaseHandle arg1 ;
59593   Dali::BaseHandle *argp1 ;
59594   Dali::Toolkit::Alignment result;
59595
59596   argp1 = (Dali::BaseHandle *)jarg1;
59597   if (!argp1) {
59598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
59599     return 0;
59600   }
59601   arg1 = *argp1;
59602   {
59603     try {
59604       result = Dali::Toolkit::Alignment::DownCast(arg1);
59605     } catch (std::out_of_range& e) {
59606       {
59607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59608       };
59609     } catch (std::exception& e) {
59610       {
59611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59612       };
59613     } catch (...) {
59614       {
59615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59616       };
59617     }
59618   }
59619   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59620   return jresult;
59621 }
59622
59623
59624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
59625   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59626   Dali::Toolkit::Alignment::Type arg2 ;
59627
59628   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59629   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
59630   {
59631     try {
59632       (arg1)->SetAlignmentType(arg2);
59633     } catch (std::out_of_range& e) {
59634       {
59635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59636       };
59637     } catch (std::exception& e) {
59638       {
59639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59640       };
59641     } catch (...) {
59642       {
59643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59644       };
59645     }
59646   }
59647 }
59648
59649
59650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
59651   int jresult ;
59652   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59653   Dali::Toolkit::Alignment::Type result;
59654
59655   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59656   {
59657     try {
59658       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
59659     } catch (std::out_of_range& e) {
59660       {
59661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59662       };
59663     } catch (std::exception& e) {
59664       {
59665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59666       };
59667     } catch (...) {
59668       {
59669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59670       };
59671     }
59672   }
59673   jresult = (int)result;
59674   return jresult;
59675 }
59676
59677
59678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
59679   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59680   Dali::Toolkit::Alignment::Scaling arg2 ;
59681
59682   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59683   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
59684   {
59685     try {
59686       (arg1)->SetScaling(arg2);
59687     } catch (std::out_of_range& e) {
59688       {
59689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59690       };
59691     } catch (std::exception& e) {
59692       {
59693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59694       };
59695     } catch (...) {
59696       {
59697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59698       };
59699     }
59700   }
59701 }
59702
59703
59704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
59705   int jresult ;
59706   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59707   Dali::Toolkit::Alignment::Scaling result;
59708
59709   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59710   {
59711     try {
59712       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
59713     } catch (std::out_of_range& e) {
59714       {
59715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59716       };
59717     } catch (std::exception& e) {
59718       {
59719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59720       };
59721     } catch (...) {
59722       {
59723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59724       };
59725     }
59726   }
59727   jresult = (int)result;
59728   return jresult;
59729 }
59730
59731
59732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
59733   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59734   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
59735
59736   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59737   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
59738   if (!arg2) {
59739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
59740     return ;
59741   }
59742   {
59743     try {
59744       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
59745     } catch (std::out_of_range& e) {
59746       {
59747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59748       };
59749     } catch (std::exception& e) {
59750       {
59751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59752       };
59753     } catch (...) {
59754       {
59755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59756       };
59757     }
59758   }
59759 }
59760
59761
59762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
59763   void * jresult ;
59764   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59765   Dali::Toolkit::Alignment::Padding *result = 0 ;
59766
59767   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59768   {
59769     try {
59770       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
59771     } catch (std::out_of_range& e) {
59772       {
59773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59774       };
59775     } catch (std::exception& e) {
59776       {
59777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59778       };
59779     } catch (...) {
59780       {
59781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59782       };
59783     }
59784   }
59785   jresult = (void *)result;
59786   return jresult;
59787 }
59788
59789
59790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
59791   void * jresult ;
59792   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59793   Dali::Toolkit::Alignment *arg2 = 0 ;
59794   Dali::Toolkit::Alignment *result = 0 ;
59795
59796   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59797   arg2 = (Dali::Toolkit::Alignment *)jarg2;
59798   if (!arg2) {
59799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
59800     return 0;
59801   }
59802   {
59803     try {
59804       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
59805     } catch (std::out_of_range& e) {
59806       {
59807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59808       };
59809     } catch (std::exception& e) {
59810       {
59811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59812       };
59813     } catch (...) {
59814       {
59815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59816       };
59817     }
59818   }
59819   jresult = (void *)result;
59820   return jresult;
59821 }
59822
59823
59824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
59825   int jresult ;
59826   int result;
59827
59828   result = (int)Dali::Toolkit::Button::Property::DISABLED;
59829   jresult = (int)result;
59830   return jresult;
59831 }
59832
59833
59834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
59835   int jresult ;
59836   int result;
59837
59838   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
59839   jresult = (int)result;
59840   return jresult;
59841 }
59842
59843
59844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
59845   int jresult ;
59846   int result;
59847
59848   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
59849   jresult = (int)result;
59850   return jresult;
59851 }
59852
59853
59854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
59855   int jresult ;
59856   int result;
59857
59858   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
59859   jresult = (int)result;
59860   return jresult;
59861 }
59862
59863
59864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
59865   int jresult ;
59866   int result;
59867
59868   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
59869   jresult = (int)result;
59870   return jresult;
59871 }
59872
59873
59874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
59875   int jresult ;
59876   int result;
59877
59878   result = (int)Dali::Toolkit::Button::Property::SELECTED;
59879   jresult = (int)result;
59880   return jresult;
59881 }
59882
59883
59884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
59885   int jresult ;
59886   int result;
59887
59888   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
59889   jresult = (int)result;
59890   return jresult;
59891 }
59892
59893
59894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
59895   int jresult ;
59896   int result;
59897
59898   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
59899   jresult = (int)result;
59900   return jresult;
59901 }
59902
59903
59904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
59905   int jresult ;
59906   int result;
59907
59908   result = (int)Dali::Toolkit::Button::Property::LABEL;
59909   jresult = (int)result;
59910   return jresult;
59911 }
59912
59913
59914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
59915   int jresult ;
59916   int result;
59917
59918   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
59919   jresult = (int)result;
59920   return jresult;
59921 }
59922
59923
59924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
59925   void * jresult ;
59926   Dali::Toolkit::Button::Property *result = 0 ;
59927
59928   {
59929     try {
59930       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
59931     } catch (std::out_of_range& e) {
59932       {
59933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59934       };
59935     } catch (std::exception& e) {
59936       {
59937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59938       };
59939     } catch (...) {
59940       {
59941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59942       };
59943     }
59944   }
59945   jresult = (void *)result;
59946   return jresult;
59947 }
59948
59949
59950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
59951   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
59952
59953   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
59954   {
59955     try {
59956       delete arg1;
59957     } catch (std::out_of_range& e) {
59958       {
59959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59960       };
59961     } catch (std::exception& e) {
59962       {
59963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59964       };
59965     } catch (...) {
59966       {
59967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59968       };
59969     }
59970   }
59971 }
59972
59973
59974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
59975   void * jresult ;
59976   Dali::Toolkit::Button *result = 0 ;
59977
59978   {
59979     try {
59980       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
59981     } catch (std::out_of_range& e) {
59982       {
59983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59984       };
59985     } catch (std::exception& e) {
59986       {
59987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59988       };
59989     } catch (...) {
59990       {
59991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59992       };
59993     }
59994   }
59995   jresult = (void *)result;
59996   return jresult;
59997 }
59998
59999
60000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
60001   void * jresult ;
60002   Dali::Toolkit::Button *arg1 = 0 ;
60003   Dali::Toolkit::Button *result = 0 ;
60004
60005   arg1 = (Dali::Toolkit::Button *)jarg1;
60006   if (!arg1) {
60007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
60008     return 0;
60009   }
60010   {
60011     try {
60012       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
60013     } catch (std::out_of_range& e) {
60014       {
60015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60016       };
60017     } catch (std::exception& e) {
60018       {
60019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60020       };
60021     } catch (...) {
60022       {
60023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60024       };
60025     }
60026   }
60027   jresult = (void *)result;
60028   return jresult;
60029 }
60030
60031
60032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
60033   void * jresult ;
60034   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60035   Dali::Toolkit::Button *arg2 = 0 ;
60036   Dali::Toolkit::Button *result = 0 ;
60037
60038   arg1 = (Dali::Toolkit::Button *)jarg1;
60039   arg2 = (Dali::Toolkit::Button *)jarg2;
60040   if (!arg2) {
60041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
60042     return 0;
60043   }
60044   {
60045     try {
60046       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
60047     } catch (std::out_of_range& e) {
60048       {
60049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60050       };
60051     } catch (std::exception& e) {
60052       {
60053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60054       };
60055     } catch (...) {
60056       {
60057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60058       };
60059     }
60060   }
60061   jresult = (void *)result;
60062   return jresult;
60063 }
60064
60065
60066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
60067   void * jresult ;
60068   Dali::BaseHandle arg1 ;
60069   Dali::BaseHandle *argp1 ;
60070   Dali::Toolkit::Button result;
60071
60072   argp1 = (Dali::BaseHandle *)jarg1;
60073   if (!argp1) {
60074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
60075     return 0;
60076   }
60077   arg1 = *argp1;
60078   {
60079     try {
60080       result = Dali::Toolkit::Button::DownCast(arg1);
60081     } catch (std::out_of_range& e) {
60082       {
60083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60084       };
60085     } catch (std::exception& e) {
60086       {
60087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60088       };
60089     } catch (...) {
60090       {
60091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60092       };
60093     }
60094   }
60095   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
60096   return jresult;
60097 }
60098
60099
60100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
60101   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60102
60103   arg1 = (Dali::Toolkit::Button *)jarg1;
60104   {
60105     try {
60106       delete arg1;
60107     } catch (std::out_of_range& e) {
60108       {
60109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60110       };
60111     } catch (std::exception& e) {
60112       {
60113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60114       };
60115     } catch (...) {
60116       {
60117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60118       };
60119     }
60120   }
60121 }
60122
60123
60124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
60125   unsigned int jresult ;
60126   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60127   bool result;
60128
60129   arg1 = (Dali::Toolkit::Button *)jarg1;
60130   {
60131     try {
60132       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
60133     } catch (std::out_of_range& e) {
60134       {
60135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60136       };
60137     } catch (std::exception& e) {
60138       {
60139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60140       };
60141     } catch (...) {
60142       {
60143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60144       };
60145     }
60146   }
60147   jresult = result;
60148   return jresult;
60149 }
60150
60151
60152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
60153   unsigned int jresult ;
60154   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60155   bool result;
60156
60157   arg1 = (Dali::Toolkit::Button *)jarg1;
60158   {
60159     try {
60160       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
60161     } catch (std::out_of_range& e) {
60162       {
60163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60164       };
60165     } catch (std::exception& e) {
60166       {
60167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60168       };
60169     } catch (...) {
60170       {
60171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60172       };
60173     }
60174   }
60175   jresult = result;
60176   return jresult;
60177 }
60178
60179
60180 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
60181   float jresult ;
60182   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60183   float result;
60184
60185   arg1 = (Dali::Toolkit::Button *)jarg1;
60186   {
60187     try {
60188       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
60189     } catch (std::out_of_range& e) {
60190       {
60191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60192       };
60193     } catch (std::exception& e) {
60194       {
60195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60196       };
60197     } catch (...) {
60198       {
60199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60200       };
60201     }
60202   }
60203   jresult = result;
60204   return jresult;
60205 }
60206
60207
60208 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
60209   float jresult ;
60210   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60211   float result;
60212
60213   arg1 = (Dali::Toolkit::Button *)jarg1;
60214   {
60215     try {
60216       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
60217     } catch (std::out_of_range& e) {
60218       {
60219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60220       };
60221     } catch (std::exception& e) {
60222       {
60223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60224       };
60225     } catch (...) {
60226       {
60227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60228       };
60229     }
60230   }
60231   jresult = result;
60232   return jresult;
60233 }
60234
60235
60236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
60237   unsigned int jresult ;
60238   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60239   bool result;
60240
60241   arg1 = (Dali::Toolkit::Button *)jarg1;
60242   {
60243     try {
60244       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
60245     } catch (std::out_of_range& e) {
60246       {
60247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60248       };
60249     } catch (std::exception& e) {
60250       {
60251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60252       };
60253     } catch (...) {
60254       {
60255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60256       };
60257     }
60258   }
60259   jresult = result;
60260   return jresult;
60261 }
60262
60263
60264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
60265   unsigned int jresult ;
60266   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60267   bool result;
60268
60269   arg1 = (Dali::Toolkit::Button *)jarg1;
60270   {
60271     try {
60272       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
60273     } catch (std::out_of_range& e) {
60274       {
60275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60276       };
60277     } catch (std::exception& e) {
60278       {
60279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60280       };
60281     } catch (...) {
60282       {
60283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60284       };
60285     }
60286   }
60287   jresult = result;
60288   return jresult;
60289 }
60290
60291
60292 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
60293   float jresult ;
60294   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60295   float result;
60296
60297   arg1 = (Dali::Toolkit::Button *)jarg1;
60298   {
60299     try {
60300       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
60301     } catch (std::out_of_range& e) {
60302       {
60303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60304       };
60305     } catch (std::exception& e) {
60306       {
60307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60308       };
60309     } catch (...) {
60310       {
60311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60312       };
60313     }
60314   }
60315   jresult = result;
60316   return jresult;
60317 }
60318
60319
60320 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
60321   char * jresult ;
60322   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60323   std::string result;
60324
60325   arg1 = (Dali::Toolkit::Button *)jarg1;
60326   {
60327     try {
60328       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
60329     } catch (std::out_of_range& e) {
60330       {
60331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60332       };
60333     } catch (std::exception& e) {
60334       {
60335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60336       };
60337     } catch (...) {
60338       {
60339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60340       };
60341     }
60342   }
60343   jresult = SWIG_csharp_string_callback((&result)->c_str());
60344   return jresult;
60345 }
60346
60347
60348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
60349   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60350   Dali::Actor arg2 ;
60351   Dali::Actor *argp2 ;
60352
60353   arg1 = (Dali::Toolkit::Button *)jarg1;
60354   argp2 = (Dali::Actor *)jarg2;
60355   if (!argp2) {
60356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
60357     return ;
60358   }
60359   arg2 = *argp2;
60360   {
60361     try {
60362       (arg1)->SetLabel(arg2);
60363     } catch (std::out_of_range& e) {
60364       {
60365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60366       };
60367     } catch (std::exception& e) {
60368       {
60369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60370       };
60371     } catch (...) {
60372       {
60373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60374       };
60375     }
60376   }
60377 }
60378
60379
60380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
60381   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60382   Dali::Image arg2 ;
60383   Dali::Image *argp2 ;
60384
60385   arg1 = (Dali::Toolkit::Button *)jarg1;
60386   argp2 = (Dali::Image *)jarg2;
60387   if (!argp2) {
60388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60389     return ;
60390   }
60391   arg2 = *argp2;
60392   {
60393     try {
60394       (arg1)->SetButtonImage(arg2);
60395     } catch (std::out_of_range& e) {
60396       {
60397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60398       };
60399     } catch (std::exception& e) {
60400       {
60401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60402       };
60403     } catch (...) {
60404       {
60405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60406       };
60407     }
60408   }
60409 }
60410
60411
60412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
60413   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60414   Dali::Image arg2 ;
60415   Dali::Image *argp2 ;
60416
60417   arg1 = (Dali::Toolkit::Button *)jarg1;
60418   argp2 = (Dali::Image *)jarg2;
60419   if (!argp2) {
60420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60421     return ;
60422   }
60423   arg2 = *argp2;
60424   {
60425     try {
60426       (arg1)->SetSelectedImage(arg2);
60427     } catch (std::out_of_range& e) {
60428       {
60429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60430       };
60431     } catch (std::exception& e) {
60432       {
60433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60434       };
60435     } catch (...) {
60436       {
60437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60438       };
60439     }
60440   }
60441 }
60442
60443
60444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
60445   void * jresult ;
60446   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60447   Dali::Actor result;
60448
60449   arg1 = (Dali::Toolkit::Button *)jarg1;
60450   {
60451     try {
60452       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
60453     } catch (std::out_of_range& e) {
60454       {
60455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60456       };
60457     } catch (std::exception& e) {
60458       {
60459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60460       };
60461     } catch (...) {
60462       {
60463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60464       };
60465     }
60466   }
60467   jresult = new Dali::Actor((const Dali::Actor &)result);
60468   return jresult;
60469 }
60470
60471
60472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
60473   void * jresult ;
60474   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60475   Dali::Actor result;
60476
60477   arg1 = (Dali::Toolkit::Button *)jarg1;
60478   {
60479     try {
60480       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
60481     } catch (std::out_of_range& e) {
60482       {
60483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60484       };
60485     } catch (std::exception& e) {
60486       {
60487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60488       };
60489     } catch (...) {
60490       {
60491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60492       };
60493     }
60494   }
60495   jresult = new Dali::Actor((const Dali::Actor &)result);
60496   return jresult;
60497 }
60498
60499
60500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
60501   void * jresult ;
60502   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60503   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60504
60505   arg1 = (Dali::Toolkit::Button *)jarg1;
60506   {
60507     try {
60508       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
60509     } catch (std::out_of_range& e) {
60510       {
60511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60512       };
60513     } catch (std::exception& e) {
60514       {
60515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60516       };
60517     } catch (...) {
60518       {
60519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60520       };
60521     }
60522   }
60523   jresult = (void *)result;
60524   return jresult;
60525 }
60526
60527
60528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
60529   void * jresult ;
60530   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60531   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60532
60533   arg1 = (Dali::Toolkit::Button *)jarg1;
60534   {
60535     try {
60536       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
60537     } catch (std::out_of_range& e) {
60538       {
60539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60540       };
60541     } catch (std::exception& e) {
60542       {
60543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60544       };
60545     } catch (...) {
60546       {
60547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60548       };
60549     }
60550   }
60551   jresult = (void *)result;
60552   return jresult;
60553 }
60554
60555
60556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
60557   void * jresult ;
60558   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60559   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60560
60561   arg1 = (Dali::Toolkit::Button *)jarg1;
60562   {
60563     try {
60564       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
60565     } catch (std::out_of_range& e) {
60566       {
60567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60568       };
60569     } catch (std::exception& e) {
60570       {
60571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60572       };
60573     } catch (...) {
60574       {
60575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60576       };
60577     }
60578   }
60579   jresult = (void *)result;
60580   return jresult;
60581 }
60582
60583
60584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
60585   void * jresult ;
60586   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60587   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60588
60589   arg1 = (Dali::Toolkit::Button *)jarg1;
60590   {
60591     try {
60592       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
60593     } catch (std::out_of_range& e) {
60594       {
60595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60596       };
60597     } catch (std::exception& e) {
60598       {
60599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60600       };
60601     } catch (...) {
60602       {
60603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60604       };
60605     }
60606   }
60607   jresult = (void *)result;
60608   return jresult;
60609 }
60610
60611
60612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
60613   void * jresult ;
60614   Dali::Toolkit::CheckBoxButton *result = 0 ;
60615
60616   {
60617     try {
60618       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
60619     } catch (std::out_of_range& e) {
60620       {
60621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60622       };
60623     } catch (std::exception& e) {
60624       {
60625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60626       };
60627     } catch (...) {
60628       {
60629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60630       };
60631     }
60632   }
60633   jresult = (void *)result;
60634   return jresult;
60635 }
60636
60637
60638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
60639   void * jresult ;
60640   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
60641   Dali::Toolkit::CheckBoxButton *result = 0 ;
60642
60643   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60644   if (!arg1) {
60645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
60646     return 0;
60647   }
60648   {
60649     try {
60650       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
60651     } catch (std::out_of_range& e) {
60652       {
60653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60654       };
60655     } catch (std::exception& e) {
60656       {
60657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60658       };
60659     } catch (...) {
60660       {
60661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60662       };
60663     }
60664   }
60665   jresult = (void *)result;
60666   return jresult;
60667 }
60668
60669
60670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
60671   void * jresult ;
60672   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
60673   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
60674   Dali::Toolkit::CheckBoxButton *result = 0 ;
60675
60676   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60677   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
60678   if (!arg2) {
60679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
60680     return 0;
60681   }
60682   {
60683     try {
60684       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
60685     } catch (std::out_of_range& e) {
60686       {
60687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60688       };
60689     } catch (std::exception& e) {
60690       {
60691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60692       };
60693     } catch (...) {
60694       {
60695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60696       };
60697     }
60698   }
60699   jresult = (void *)result;
60700   return jresult;
60701 }
60702
60703
60704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
60705   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
60706
60707   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60708   {
60709     try {
60710       delete arg1;
60711     } catch (std::out_of_range& e) {
60712       {
60713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60714       };
60715     } catch (std::exception& e) {
60716       {
60717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60718       };
60719     } catch (...) {
60720       {
60721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60722       };
60723     }
60724   }
60725 }
60726
60727
60728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
60729   void * jresult ;
60730   Dali::Toolkit::CheckBoxButton result;
60731
60732   {
60733     try {
60734       result = Dali::Toolkit::CheckBoxButton::New();
60735     } catch (std::out_of_range& e) {
60736       {
60737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60738       };
60739     } catch (std::exception& e) {
60740       {
60741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60742       };
60743     } catch (...) {
60744       {
60745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60746       };
60747     }
60748   }
60749   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
60750   return jresult;
60751 }
60752
60753
60754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
60755   void * jresult ;
60756   Dali::BaseHandle arg1 ;
60757   Dali::BaseHandle *argp1 ;
60758   Dali::Toolkit::CheckBoxButton result;
60759
60760   argp1 = (Dali::BaseHandle *)jarg1;
60761   if (!argp1) {
60762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
60763     return 0;
60764   }
60765   arg1 = *argp1;
60766   {
60767     try {
60768       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
60769     } catch (std::out_of_range& e) {
60770       {
60771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60772       };
60773     } catch (std::exception& e) {
60774       {
60775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60776       };
60777     } catch (...) {
60778       {
60779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60780       };
60781     }
60782   }
60783   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
60784   return jresult;
60785 }
60786
60787
60788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
60789   int jresult ;
60790   int result;
60791
60792   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
60793   jresult = (int)result;
60794   return jresult;
60795 }
60796
60797
60798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
60799   int jresult ;
60800   int result;
60801
60802   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
60803   jresult = (int)result;
60804   return jresult;
60805 }
60806
60807
60808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
60809   int jresult ;
60810   int result;
60811
60812   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
60813   jresult = (int)result;
60814   return jresult;
60815 }
60816
60817
60818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
60819   int jresult ;
60820   int result;
60821
60822   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
60823   jresult = (int)result;
60824   return jresult;
60825 }
60826
60827
60828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
60829   int jresult ;
60830   int result;
60831
60832   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
60833   jresult = (int)result;
60834   return jresult;
60835 }
60836
60837
60838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
60839   void * jresult ;
60840   Dali::Toolkit::PushButton::Property *result = 0 ;
60841
60842   {
60843     try {
60844       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
60845     } catch (std::out_of_range& e) {
60846       {
60847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60848       };
60849     } catch (std::exception& e) {
60850       {
60851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60852       };
60853     } catch (...) {
60854       {
60855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60856       };
60857     }
60858   }
60859   jresult = (void *)result;
60860   return jresult;
60861 }
60862
60863
60864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
60865   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
60866
60867   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
60868   {
60869     try {
60870       delete arg1;
60871     } catch (std::out_of_range& e) {
60872       {
60873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60874       };
60875     } catch (std::exception& e) {
60876       {
60877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60878       };
60879     } catch (...) {
60880       {
60881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60882       };
60883     }
60884   }
60885 }
60886
60887
60888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
60889   void * jresult ;
60890   Dali::Toolkit::PushButton *result = 0 ;
60891
60892   {
60893     try {
60894       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
60895     } catch (std::out_of_range& e) {
60896       {
60897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60898       };
60899     } catch (std::exception& e) {
60900       {
60901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60902       };
60903     } catch (...) {
60904       {
60905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60906       };
60907     }
60908   }
60909   jresult = (void *)result;
60910   return jresult;
60911 }
60912
60913
60914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
60915   void * jresult ;
60916   Dali::Toolkit::PushButton *arg1 = 0 ;
60917   Dali::Toolkit::PushButton *result = 0 ;
60918
60919   arg1 = (Dali::Toolkit::PushButton *)jarg1;
60920   if (!arg1) {
60921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
60922     return 0;
60923   }
60924   {
60925     try {
60926       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
60927     } catch (std::out_of_range& e) {
60928       {
60929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60930       };
60931     } catch (std::exception& e) {
60932       {
60933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60934       };
60935     } catch (...) {
60936       {
60937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60938       };
60939     }
60940   }
60941   jresult = (void *)result;
60942   return jresult;
60943 }
60944
60945
60946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
60947   void * jresult ;
60948   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
60949   Dali::Toolkit::PushButton *arg2 = 0 ;
60950   Dali::Toolkit::PushButton *result = 0 ;
60951
60952   arg1 = (Dali::Toolkit::PushButton *)jarg1;
60953   arg2 = (Dali::Toolkit::PushButton *)jarg2;
60954   if (!arg2) {
60955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
60956     return 0;
60957   }
60958   {
60959     try {
60960       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
60961     } catch (std::out_of_range& e) {
60962       {
60963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60964       };
60965     } catch (std::exception& e) {
60966       {
60967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60968       };
60969     } catch (...) {
60970       {
60971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60972       };
60973     }
60974   }
60975   jresult = (void *)result;
60976   return jresult;
60977 }
60978
60979
60980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
60981   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
60982
60983   arg1 = (Dali::Toolkit::PushButton *)jarg1;
60984   {
60985     try {
60986       delete arg1;
60987     } catch (std::out_of_range& e) {
60988       {
60989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60990       };
60991     } catch (std::exception& e) {
60992       {
60993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60994       };
60995     } catch (...) {
60996       {
60997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60998       };
60999     }
61000   }
61001 }
61002
61003
61004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
61005   void * jresult ;
61006   Dali::Toolkit::PushButton result;
61007
61008   {
61009     try {
61010       result = Dali::Toolkit::PushButton::New();
61011     } catch (std::out_of_range& e) {
61012       {
61013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61014       };
61015     } catch (std::exception& e) {
61016       {
61017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61018       };
61019     } catch (...) {
61020       {
61021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61022       };
61023     }
61024   }
61025   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
61026   return jresult;
61027 }
61028
61029
61030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
61031   void * jresult ;
61032   Dali::BaseHandle arg1 ;
61033   Dali::BaseHandle *argp1 ;
61034   Dali::Toolkit::PushButton result;
61035
61036   argp1 = (Dali::BaseHandle *)jarg1;
61037   if (!argp1) {
61038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61039     return 0;
61040   }
61041   arg1 = *argp1;
61042   {
61043     try {
61044       result = Dali::Toolkit::PushButton::DownCast(arg1);
61045     } catch (std::out_of_range& e) {
61046       {
61047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61048       };
61049     } catch (std::exception& e) {
61050       {
61051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61052       };
61053     } catch (...) {
61054       {
61055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61056       };
61057     }
61058   }
61059   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
61060   return jresult;
61061 }
61062
61063
61064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
61065   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61066   Dali::Image arg2 ;
61067   Dali::Image *argp2 ;
61068
61069   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61070   argp2 = (Dali::Image *)jarg2;
61071   if (!argp2) {
61072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
61073     return ;
61074   }
61075   arg2 = *argp2;
61076   {
61077     try {
61078       (arg1)->SetButtonImage(arg2);
61079     } catch (std::out_of_range& e) {
61080       {
61081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61082       };
61083     } catch (std::exception& e) {
61084       {
61085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61086       };
61087     } catch (...) {
61088       {
61089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61090       };
61091     }
61092   }
61093 }
61094
61095
61096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
61097   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61098   Dali::Actor arg2 ;
61099   Dali::Actor *argp2 ;
61100
61101   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61102   argp2 = (Dali::Actor *)jarg2;
61103   if (!argp2) {
61104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61105     return ;
61106   }
61107   arg2 = *argp2;
61108   {
61109     try {
61110       (arg1)->SetButtonImage(arg2);
61111     } catch (std::out_of_range& e) {
61112       {
61113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61114       };
61115     } catch (std::exception& e) {
61116       {
61117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61118       };
61119     } catch (...) {
61120       {
61121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61122       };
61123     }
61124   }
61125 }
61126
61127
61128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
61129   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61130   Dali::Actor arg2 ;
61131   Dali::Actor *argp2 ;
61132
61133   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61134   argp2 = (Dali::Actor *)jarg2;
61135   if (!argp2) {
61136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61137     return ;
61138   }
61139   arg2 = *argp2;
61140   {
61141     try {
61142       (arg1)->SetBackgroundImage(arg2);
61143     } catch (std::out_of_range& e) {
61144       {
61145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61146       };
61147     } catch (std::exception& e) {
61148       {
61149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61150       };
61151     } catch (...) {
61152       {
61153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61154       };
61155     }
61156   }
61157 }
61158
61159
61160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
61161   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61162   Dali::Image arg2 ;
61163   Dali::Image *argp2 ;
61164
61165   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61166   argp2 = (Dali::Image *)jarg2;
61167   if (!argp2) {
61168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
61169     return ;
61170   }
61171   arg2 = *argp2;
61172   {
61173     try {
61174       (arg1)->SetSelectedImage(arg2);
61175     } catch (std::out_of_range& e) {
61176       {
61177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61178       };
61179     } catch (std::exception& e) {
61180       {
61181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61182       };
61183     } catch (...) {
61184       {
61185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61186       };
61187     }
61188   }
61189 }
61190
61191
61192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
61193   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61194   Dali::Actor arg2 ;
61195   Dali::Actor *argp2 ;
61196
61197   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61198   argp2 = (Dali::Actor *)jarg2;
61199   if (!argp2) {
61200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61201     return ;
61202   }
61203   arg2 = *argp2;
61204   {
61205     try {
61206       (arg1)->SetSelectedImage(arg2);
61207     } catch (std::out_of_range& e) {
61208       {
61209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61210       };
61211     } catch (std::exception& e) {
61212       {
61213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61214       };
61215     } catch (...) {
61216       {
61217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61218       };
61219     }
61220   }
61221 }
61222
61223
61224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
61225   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61226   Dali::Actor arg2 ;
61227   Dali::Actor *argp2 ;
61228
61229   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61230   argp2 = (Dali::Actor *)jarg2;
61231   if (!argp2) {
61232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61233     return ;
61234   }
61235   arg2 = *argp2;
61236   {
61237     try {
61238       (arg1)->SetSelectedBackgroundImage(arg2);
61239     } catch (std::out_of_range& e) {
61240       {
61241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61242       };
61243     } catch (std::exception& e) {
61244       {
61245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61246       };
61247     } catch (...) {
61248       {
61249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61250       };
61251     }
61252   }
61253 }
61254
61255
61256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
61257   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61258   Dali::Actor arg2 ;
61259   Dali::Actor *argp2 ;
61260
61261   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61262   argp2 = (Dali::Actor *)jarg2;
61263   if (!argp2) {
61264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61265     return ;
61266   }
61267   arg2 = *argp2;
61268   {
61269     try {
61270       (arg1)->SetDisabledBackgroundImage(arg2);
61271     } catch (std::out_of_range& e) {
61272       {
61273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61274       };
61275     } catch (std::exception& e) {
61276       {
61277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61278       };
61279     } catch (...) {
61280       {
61281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61282       };
61283     }
61284   }
61285 }
61286
61287
61288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
61289   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61290   Dali::Actor arg2 ;
61291   Dali::Actor *argp2 ;
61292
61293   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61294   argp2 = (Dali::Actor *)jarg2;
61295   if (!argp2) {
61296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61297     return ;
61298   }
61299   arg2 = *argp2;
61300   {
61301     try {
61302       (arg1)->SetDisabledImage(arg2);
61303     } catch (std::out_of_range& e) {
61304       {
61305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61306       };
61307     } catch (std::exception& e) {
61308       {
61309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61310       };
61311     } catch (...) {
61312       {
61313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61314       };
61315     }
61316   }
61317 }
61318
61319
61320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
61321   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61322   Dali::Actor arg2 ;
61323   Dali::Actor *argp2 ;
61324
61325   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61326   argp2 = (Dali::Actor *)jarg2;
61327   if (!argp2) {
61328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61329     return ;
61330   }
61331   arg2 = *argp2;
61332   {
61333     try {
61334       (arg1)->SetDisabledSelectedImage(arg2);
61335     } catch (std::out_of_range& e) {
61336       {
61337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61338       };
61339     } catch (std::exception& e) {
61340       {
61341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61342       };
61343     } catch (...) {
61344       {
61345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61346       };
61347     }
61348   }
61349 }
61350
61351
61352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
61353   void * jresult ;
61354   Dali::Toolkit::RadioButton *result = 0 ;
61355
61356   {
61357     try {
61358       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
61359     } catch (std::out_of_range& e) {
61360       {
61361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61362       };
61363     } catch (std::exception& e) {
61364       {
61365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61366       };
61367     } catch (...) {
61368       {
61369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61370       };
61371     }
61372   }
61373   jresult = (void *)result;
61374   return jresult;
61375 }
61376
61377
61378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
61379   void * jresult ;
61380   Dali::Toolkit::RadioButton *arg1 = 0 ;
61381   Dali::Toolkit::RadioButton *result = 0 ;
61382
61383   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61384   if (!arg1) {
61385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
61386     return 0;
61387   }
61388   {
61389     try {
61390       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
61391     } catch (std::out_of_range& e) {
61392       {
61393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61394       };
61395     } catch (std::exception& e) {
61396       {
61397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61398       };
61399     } catch (...) {
61400       {
61401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61402       };
61403     }
61404   }
61405   jresult = (void *)result;
61406   return jresult;
61407 }
61408
61409
61410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
61411   void * jresult ;
61412   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
61413   Dali::Toolkit::RadioButton *arg2 = 0 ;
61414   Dali::Toolkit::RadioButton *result = 0 ;
61415
61416   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61417   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
61418   if (!arg2) {
61419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
61420     return 0;
61421   }
61422   {
61423     try {
61424       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
61425     } catch (std::out_of_range& e) {
61426       {
61427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61428       };
61429     } catch (std::exception& e) {
61430       {
61431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61432       };
61433     } catch (...) {
61434       {
61435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61436       };
61437     }
61438   }
61439   jresult = (void *)result;
61440   return jresult;
61441 }
61442
61443
61444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
61445   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
61446
61447   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61448   {
61449     try {
61450       delete arg1;
61451     } catch (std::out_of_range& e) {
61452       {
61453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61454       };
61455     } catch (std::exception& e) {
61456       {
61457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61458       };
61459     } catch (...) {
61460       {
61461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61462       };
61463     }
61464   }
61465 }
61466
61467
61468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
61469   void * jresult ;
61470   Dali::Toolkit::RadioButton result;
61471
61472   {
61473     try {
61474       result = Dali::Toolkit::RadioButton::New();
61475     } catch (std::out_of_range& e) {
61476       {
61477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61478       };
61479     } catch (std::exception& e) {
61480       {
61481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61482       };
61483     } catch (...) {
61484       {
61485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61486       };
61487     }
61488   }
61489   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61490   return jresult;
61491 }
61492
61493
61494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
61495   void * jresult ;
61496   std::string *arg1 = 0 ;
61497   Dali::Toolkit::RadioButton result;
61498
61499   if (!jarg1) {
61500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61501     return 0;
61502   }
61503   std::string arg1_str(jarg1);
61504   arg1 = &arg1_str;
61505   {
61506     try {
61507       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
61508     } catch (std::out_of_range& e) {
61509       {
61510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61511       };
61512     } catch (std::exception& e) {
61513       {
61514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61515       };
61516     } catch (...) {
61517       {
61518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61519       };
61520     }
61521   }
61522   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61523
61524   //argout typemap for const std::string&
61525
61526   return jresult;
61527 }
61528
61529
61530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
61531   void * jresult ;
61532   Dali::BaseHandle arg1 ;
61533   Dali::BaseHandle *argp1 ;
61534   Dali::Toolkit::RadioButton result;
61535
61536   argp1 = (Dali::BaseHandle *)jarg1;
61537   if (!argp1) {
61538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61539     return 0;
61540   }
61541   arg1 = *argp1;
61542   {
61543     try {
61544       result = Dali::Toolkit::RadioButton::DownCast(arg1);
61545     } catch (std::out_of_range& e) {
61546       {
61547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61548       };
61549     } catch (std::exception& e) {
61550       {
61551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61552       };
61553     } catch (...) {
61554       {
61555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61556       };
61557     }
61558   }
61559   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61560   return jresult;
61561 }
61562
61563
61564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
61565   int jresult ;
61566   int result;
61567
61568   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
61569   jresult = (int)result;
61570   return jresult;
61571 }
61572
61573
61574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
61575   int jresult ;
61576   int result;
61577
61578   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
61579   jresult = (int)result;
61580   return jresult;
61581 }
61582
61583
61584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
61585   int jresult ;
61586   int result;
61587
61588   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
61589   jresult = (int)result;
61590   return jresult;
61591 }
61592
61593
61594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
61595   int jresult ;
61596   int result;
61597
61598   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
61599   jresult = (int)result;
61600   return jresult;
61601 }
61602
61603
61604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
61605   int jresult ;
61606   int result;
61607
61608   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
61609   jresult = (int)result;
61610   return jresult;
61611 }
61612
61613
61614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
61615   int jresult ;
61616   int result;
61617
61618   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
61619   jresult = (int)result;
61620   return jresult;
61621 }
61622
61623
61624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
61625   void * jresult ;
61626   Dali::Toolkit::FlexContainer::Property *result = 0 ;
61627
61628   {
61629     try {
61630       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
61631     } catch (std::out_of_range& e) {
61632       {
61633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61634       };
61635     } catch (std::exception& e) {
61636       {
61637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61638       };
61639     } catch (...) {
61640       {
61641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61642       };
61643     }
61644   }
61645   jresult = (void *)result;
61646   return jresult;
61647 }
61648
61649
61650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
61651   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
61652
61653   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
61654   {
61655     try {
61656       delete arg1;
61657     } catch (std::out_of_range& e) {
61658       {
61659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61660       };
61661     } catch (std::exception& e) {
61662       {
61663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61664       };
61665     } catch (...) {
61666       {
61667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61668       };
61669     }
61670   }
61671 }
61672
61673
61674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
61675   int jresult ;
61676   int result;
61677
61678   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
61679   jresult = (int)result;
61680   return jresult;
61681 }
61682
61683
61684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
61685   int jresult ;
61686   int result;
61687
61688   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
61689   jresult = (int)result;
61690   return jresult;
61691 }
61692
61693
61694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
61695   int jresult ;
61696   int result;
61697
61698   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
61699   jresult = (int)result;
61700   return jresult;
61701 }
61702
61703
61704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
61705   void * jresult ;
61706   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
61707
61708   {
61709     try {
61710       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
61711     } catch (std::out_of_range& e) {
61712       {
61713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61714       };
61715     } catch (std::exception& e) {
61716       {
61717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61718       };
61719     } catch (...) {
61720       {
61721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61722       };
61723     }
61724   }
61725   jresult = (void *)result;
61726   return jresult;
61727 }
61728
61729
61730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
61731   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
61732
61733   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
61734   {
61735     try {
61736       delete arg1;
61737     } catch (std::out_of_range& e) {
61738       {
61739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61740       };
61741     } catch (std::exception& e) {
61742       {
61743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61744       };
61745     } catch (...) {
61746       {
61747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61748       };
61749     }
61750   }
61751 }
61752
61753
61754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
61755   void * jresult ;
61756   Dali::Toolkit::FlexContainer *result = 0 ;
61757
61758   {
61759     try {
61760       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
61761     } catch (std::out_of_range& e) {
61762       {
61763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61764       };
61765     } catch (std::exception& e) {
61766       {
61767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61768       };
61769     } catch (...) {
61770       {
61771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61772       };
61773     }
61774   }
61775   jresult = (void *)result;
61776   return jresult;
61777 }
61778
61779
61780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
61781   void * jresult ;
61782   Dali::Toolkit::FlexContainer *arg1 = 0 ;
61783   Dali::Toolkit::FlexContainer *result = 0 ;
61784
61785   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
61786   if (!arg1) {
61787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
61788     return 0;
61789   }
61790   {
61791     try {
61792       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
61793     } catch (std::out_of_range& e) {
61794       {
61795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61796       };
61797     } catch (std::exception& e) {
61798       {
61799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61800       };
61801     } catch (...) {
61802       {
61803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61804       };
61805     }
61806   }
61807   jresult = (void *)result;
61808   return jresult;
61809 }
61810
61811
61812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
61813   void * jresult ;
61814   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
61815   Dali::Toolkit::FlexContainer *arg2 = 0 ;
61816   Dali::Toolkit::FlexContainer *result = 0 ;
61817
61818   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
61819   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
61820   if (!arg2) {
61821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
61822     return 0;
61823   }
61824   {
61825     try {
61826       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
61827     } catch (std::out_of_range& e) {
61828       {
61829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61830       };
61831     } catch (std::exception& e) {
61832       {
61833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61834       };
61835     } catch (...) {
61836       {
61837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61838       };
61839     }
61840   }
61841   jresult = (void *)result;
61842   return jresult;
61843 }
61844
61845
61846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
61847   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
61848
61849   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
61850   {
61851     try {
61852       delete arg1;
61853     } catch (std::out_of_range& e) {
61854       {
61855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61856       };
61857     } catch (std::exception& e) {
61858       {
61859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61860       };
61861     } catch (...) {
61862       {
61863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61864       };
61865     }
61866   }
61867 }
61868
61869
61870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
61871   void * jresult ;
61872   Dali::Toolkit::FlexContainer result;
61873
61874   {
61875     try {
61876       result = Dali::Toolkit::FlexContainer::New();
61877     } catch (std::out_of_range& e) {
61878       {
61879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61880       };
61881     } catch (std::exception& e) {
61882       {
61883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61884       };
61885     } catch (...) {
61886       {
61887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61888       };
61889     }
61890   }
61891   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
61892   return jresult;
61893 }
61894
61895
61896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
61897   void * jresult ;
61898   Dali::BaseHandle arg1 ;
61899   Dali::BaseHandle *argp1 ;
61900   Dali::Toolkit::FlexContainer result;
61901
61902   argp1 = (Dali::BaseHandle *)jarg1;
61903   if (!argp1) {
61904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61905     return 0;
61906   }
61907   arg1 = *argp1;
61908   {
61909     try {
61910       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
61911     } catch (std::out_of_range& e) {
61912       {
61913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61914       };
61915     } catch (std::exception& e) {
61916       {
61917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61918       };
61919     } catch (...) {
61920       {
61921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61922       };
61923     }
61924   }
61925   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
61926   return jresult;
61927 }
61928
61929
61930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
61931   int jresult ;
61932   int result;
61933
61934   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
61935   jresult = (int)result;
61936   return jresult;
61937 }
61938
61939
61940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
61941   int jresult ;
61942   int result;
61943
61944   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
61945   jresult = (int)result;
61946   return jresult;
61947 }
61948
61949
61950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
61951   int jresult ;
61952   int result;
61953
61954   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
61955   jresult = (int)result;
61956   return jresult;
61957 }
61958
61959
61960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
61961   int jresult ;
61962   int result;
61963
61964   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
61965   jresult = (int)result;
61966   return jresult;
61967 }
61968
61969
61970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
61971   void * jresult ;
61972   Dali::Toolkit::ImageView::Property *result = 0 ;
61973
61974   {
61975     try {
61976       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
61977     } catch (std::out_of_range& e) {
61978       {
61979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61980       };
61981     } catch (std::exception& e) {
61982       {
61983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61984       };
61985     } catch (...) {
61986       {
61987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61988       };
61989     }
61990   }
61991   jresult = (void *)result;
61992   return jresult;
61993 }
61994
61995
61996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
61997   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
61998
61999   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
62000   {
62001     try {
62002       delete arg1;
62003     } catch (std::out_of_range& e) {
62004       {
62005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62006       };
62007     } catch (std::exception& e) {
62008       {
62009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62010       };
62011     } catch (...) {
62012       {
62013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62014       };
62015     }
62016   }
62017 }
62018
62019
62020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
62021   void * jresult ;
62022   Dali::Toolkit::ImageView *result = 0 ;
62023
62024   {
62025     try {
62026       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
62027     } catch (std::out_of_range& e) {
62028       {
62029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62030       };
62031     } catch (std::exception& e) {
62032       {
62033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62034       };
62035     } catch (...) {
62036       {
62037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62038       };
62039     }
62040   }
62041   jresult = (void *)result;
62042   return jresult;
62043 }
62044
62045
62046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
62047   void * jresult ;
62048   Dali::Toolkit::ImageView result;
62049
62050   {
62051     try {
62052       result = Dali::Toolkit::ImageView::New();
62053     } catch (std::out_of_range& e) {
62054       {
62055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62056       };
62057     } catch (std::exception& e) {
62058       {
62059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62060       };
62061     } catch (...) {
62062       {
62063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62064       };
62065     }
62066   }
62067   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62068   return jresult;
62069 }
62070
62071
62072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
62073   void * jresult ;
62074   Dali::Image arg1 ;
62075   Dali::Image *argp1 ;
62076   Dali::Toolkit::ImageView result;
62077
62078   argp1 = (Dali::Image *)jarg1;
62079   if (!argp1) {
62080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62081     return 0;
62082   }
62083   arg1 = *argp1;
62084   {
62085     try {
62086       result = Dali::Toolkit::ImageView::New(arg1);
62087     } catch (std::out_of_range& e) {
62088       {
62089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62090       };
62091     } catch (std::exception& e) {
62092       {
62093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62094       };
62095     } catch (...) {
62096       {
62097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62098       };
62099     }
62100   }
62101   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62102   return jresult;
62103 }
62104
62105
62106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
62107   void * jresult ;
62108   std::string *arg1 = 0 ;
62109   Dali::Toolkit::ImageView result;
62110
62111   if (!jarg1) {
62112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62113     return 0;
62114   }
62115   std::string arg1_str(jarg1);
62116   arg1 = &arg1_str;
62117   {
62118     try {
62119       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
62120     } catch (std::out_of_range& e) {
62121       {
62122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62123       };
62124     } catch (std::exception& e) {
62125       {
62126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62127       };
62128     } catch (...) {
62129       {
62130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62131       };
62132     }
62133   }
62134   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62135
62136   //argout typemap for const std::string&
62137
62138   return jresult;
62139 }
62140
62141
62142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
62143   void * jresult ;
62144   std::string *arg1 = 0 ;
62145   Dali::ImageDimensions arg2 ;
62146   Dali::ImageDimensions *argp2 ;
62147   Dali::Toolkit::ImageView result;
62148
62149   if (!jarg1) {
62150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62151     return 0;
62152   }
62153   std::string arg1_str(jarg1);
62154   arg1 = &arg1_str;
62155   argp2 = (Dali::ImageDimensions *)jarg2;
62156   if (!argp2) {
62157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
62158     return 0;
62159   }
62160   arg2 = *argp2;
62161   {
62162     try {
62163       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
62164     } catch (std::out_of_range& e) {
62165       {
62166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62167       };
62168     } catch (std::exception& e) {
62169       {
62170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62171       };
62172     } catch (...) {
62173       {
62174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62175       };
62176     }
62177   }
62178   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62179
62180   //argout typemap for const std::string&
62181
62182   return jresult;
62183 }
62184
62185
62186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
62187   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62188
62189   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62190   {
62191     try {
62192       delete arg1;
62193     } catch (std::out_of_range& e) {
62194       {
62195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62196       };
62197     } catch (std::exception& e) {
62198       {
62199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62200       };
62201     } catch (...) {
62202       {
62203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62204       };
62205     }
62206   }
62207 }
62208
62209
62210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
62211   void * jresult ;
62212   Dali::Toolkit::ImageView *arg1 = 0 ;
62213   Dali::Toolkit::ImageView *result = 0 ;
62214
62215   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62216   if (!arg1) {
62217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
62218     return 0;
62219   }
62220   {
62221     try {
62222       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
62223     } catch (std::out_of_range& e) {
62224       {
62225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62226       };
62227     } catch (std::exception& e) {
62228       {
62229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62230       };
62231     } catch (...) {
62232       {
62233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62234       };
62235     }
62236   }
62237   jresult = (void *)result;
62238   return jresult;
62239 }
62240
62241
62242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
62243   void * jresult ;
62244   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62245   Dali::Toolkit::ImageView *arg2 = 0 ;
62246   Dali::Toolkit::ImageView *result = 0 ;
62247
62248   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62249   arg2 = (Dali::Toolkit::ImageView *)jarg2;
62250   if (!arg2) {
62251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
62252     return 0;
62253   }
62254   {
62255     try {
62256       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
62257     } catch (std::out_of_range& e) {
62258       {
62259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62260       };
62261     } catch (std::exception& e) {
62262       {
62263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62264       };
62265     } catch (...) {
62266       {
62267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62268       };
62269     }
62270   }
62271   jresult = (void *)result;
62272   return jresult;
62273 }
62274
62275
62276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
62277   void * jresult ;
62278   Dali::BaseHandle arg1 ;
62279   Dali::BaseHandle *argp1 ;
62280   Dali::Toolkit::ImageView result;
62281
62282   argp1 = (Dali::BaseHandle *)jarg1;
62283   if (!argp1) {
62284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62285     return 0;
62286   }
62287   arg1 = *argp1;
62288   {
62289     try {
62290       result = Dali::Toolkit::ImageView::DownCast(arg1);
62291     } catch (std::out_of_range& e) {
62292       {
62293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62294       };
62295     } catch (std::exception& e) {
62296       {
62297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62298       };
62299     } catch (...) {
62300       {
62301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62302       };
62303     }
62304   }
62305   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62306   return jresult;
62307 }
62308
62309
62310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
62311   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62312   Dali::Image arg2 ;
62313   Dali::Image *argp2 ;
62314
62315   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62316   argp2 = (Dali::Image *)jarg2;
62317   if (!argp2) {
62318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62319     return ;
62320   }
62321   arg2 = *argp2;
62322   {
62323     try {
62324       (arg1)->SetImage(arg2);
62325     } catch (std::out_of_range& e) {
62326       {
62327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62328       };
62329     } catch (std::exception& e) {
62330       {
62331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62332       };
62333     } catch (...) {
62334       {
62335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62336       };
62337     }
62338   }
62339 }
62340
62341
62342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
62343   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62344   std::string *arg2 = 0 ;
62345
62346   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62347   if (!jarg2) {
62348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62349     return ;
62350   }
62351   std::string arg2_str(jarg2);
62352   arg2 = &arg2_str;
62353   {
62354     try {
62355       (arg1)->SetImage((std::string const &)*arg2);
62356     } catch (std::out_of_range& e) {
62357       {
62358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62359       };
62360     } catch (std::exception& e) {
62361       {
62362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62363       };
62364     } catch (...) {
62365       {
62366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62367       };
62368     }
62369   }
62370
62371   //argout typemap for const std::string&
62372
62373 }
62374
62375
62376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
62377   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62378   std::string *arg2 = 0 ;
62379   Dali::ImageDimensions arg3 ;
62380   Dali::ImageDimensions *argp3 ;
62381
62382   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62383   if (!jarg2) {
62384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62385     return ;
62386   }
62387   std::string arg2_str(jarg2);
62388   arg2 = &arg2_str;
62389   argp3 = (Dali::ImageDimensions *)jarg3;
62390   if (!argp3) {
62391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
62392     return ;
62393   }
62394   arg3 = *argp3;
62395   {
62396     try {
62397       (arg1)->SetImage((std::string const &)*arg2,arg3);
62398     } catch (std::out_of_range& e) {
62399       {
62400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62401       };
62402     } catch (std::exception& e) {
62403       {
62404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62405       };
62406     } catch (...) {
62407       {
62408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62409       };
62410     }
62411   }
62412
62413   //argout typemap for const std::string&
62414
62415 }
62416
62417
62418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
62419   void * jresult ;
62420   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62421   Dali::Image result;
62422
62423   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62424   {
62425     try {
62426       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
62427     } catch (std::out_of_range& e) {
62428       {
62429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62430       };
62431     } catch (std::exception& e) {
62432       {
62433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62434       };
62435     } catch (...) {
62436       {
62437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62438       };
62439     }
62440   }
62441   jresult = new Dali::Image((const Dali::Image &)result);
62442   return jresult;
62443 }
62444
62445
62446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
62447   int jresult ;
62448   int result;
62449
62450   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
62451   jresult = (int)result;
62452   return jresult;
62453 }
62454
62455
62456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
62457   int jresult ;
62458   int result;
62459
62460   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
62461   jresult = (int)result;
62462   return jresult;
62463 }
62464
62465
62466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
62467   int jresult ;
62468   int result;
62469
62470   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
62471   jresult = (int)result;
62472   return jresult;
62473 }
62474
62475
62476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
62477   int jresult ;
62478   int result;
62479
62480   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
62481   jresult = (int)result;
62482   return jresult;
62483 }
62484
62485
62486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
62487   int jresult ;
62488   int result;
62489
62490   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
62491   jresult = (int)result;
62492   return jresult;
62493 }
62494
62495
62496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
62497   int jresult ;
62498   int result;
62499
62500   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
62501   jresult = (int)result;
62502   return jresult;
62503 }
62504
62505
62506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
62507   int jresult ;
62508   int result;
62509
62510   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
62511   jresult = (int)result;
62512   return jresult;
62513 }
62514
62515
62516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
62517   int jresult ;
62518   int result;
62519
62520   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
62521   jresult = (int)result;
62522   return jresult;
62523 }
62524
62525
62526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
62527   void * jresult ;
62528   Dali::Toolkit::Model3dView::Property *result = 0 ;
62529
62530   {
62531     try {
62532       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
62533     } catch (std::out_of_range& e) {
62534       {
62535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62536       };
62537     } catch (std::exception& e) {
62538       {
62539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62540       };
62541     } catch (...) {
62542       {
62543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62544       };
62545     }
62546   }
62547   jresult = (void *)result;
62548   return jresult;
62549 }
62550
62551
62552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
62553   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
62554
62555   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
62556   {
62557     try {
62558       delete arg1;
62559     } catch (std::out_of_range& e) {
62560       {
62561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62562       };
62563     } catch (std::exception& e) {
62564       {
62565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62566       };
62567     } catch (...) {
62568       {
62569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62570       };
62571     }
62572   }
62573 }
62574
62575
62576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
62577   void * jresult ;
62578   Dali::Toolkit::Model3dView result;
62579
62580   {
62581     try {
62582       result = Dali::Toolkit::Model3dView::New();
62583     } catch (std::out_of_range& e) {
62584       {
62585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62586       };
62587     } catch (std::exception& e) {
62588       {
62589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62590       };
62591     } catch (...) {
62592       {
62593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62594       };
62595     }
62596   }
62597   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62598   return jresult;
62599 }
62600
62601
62602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
62603   void * jresult ;
62604   std::string *arg1 = 0 ;
62605   std::string *arg2 = 0 ;
62606   std::string *arg3 = 0 ;
62607   Dali::Toolkit::Model3dView result;
62608
62609   if (!jarg1) {
62610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62611     return 0;
62612   }
62613   std::string arg1_str(jarg1);
62614   arg1 = &arg1_str;
62615   if (!jarg2) {
62616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62617     return 0;
62618   }
62619   std::string arg2_str(jarg2);
62620   arg2 = &arg2_str;
62621   if (!jarg3) {
62622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62623     return 0;
62624   }
62625   std::string arg3_str(jarg3);
62626   arg3 = &arg3_str;
62627   {
62628     try {
62629       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
62630     } catch (std::out_of_range& e) {
62631       {
62632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62633       };
62634     } catch (std::exception& e) {
62635       {
62636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62637       };
62638     } catch (...) {
62639       {
62640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62641       };
62642     }
62643   }
62644   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62645
62646   //argout typemap for const std::string&
62647
62648
62649   //argout typemap for const std::string&
62650
62651
62652   //argout typemap for const std::string&
62653
62654   return jresult;
62655 }
62656
62657
62658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
62659   void * jresult ;
62660   Dali::Toolkit::Model3dView *result = 0 ;
62661
62662   {
62663     try {
62664       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
62665     } catch (std::out_of_range& e) {
62666       {
62667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62668       };
62669     } catch (std::exception& e) {
62670       {
62671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62672       };
62673     } catch (...) {
62674       {
62675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62676       };
62677     }
62678   }
62679   jresult = (void *)result;
62680   return jresult;
62681 }
62682
62683
62684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
62685   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
62686
62687   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62688   {
62689     try {
62690       delete arg1;
62691     } catch (std::out_of_range& e) {
62692       {
62693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62694       };
62695     } catch (std::exception& e) {
62696       {
62697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62698       };
62699     } catch (...) {
62700       {
62701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62702       };
62703     }
62704   }
62705 }
62706
62707
62708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
62709   void * jresult ;
62710   Dali::Toolkit::Model3dView *arg1 = 0 ;
62711   Dali::Toolkit::Model3dView *result = 0 ;
62712
62713   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62714   if (!arg1) {
62715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
62716     return 0;
62717   }
62718   {
62719     try {
62720       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
62721     } catch (std::out_of_range& e) {
62722       {
62723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62724       };
62725     } catch (std::exception& e) {
62726       {
62727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62728       };
62729     } catch (...) {
62730       {
62731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62732       };
62733     }
62734   }
62735   jresult = (void *)result;
62736   return jresult;
62737 }
62738
62739
62740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
62741   void * jresult ;
62742   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
62743   Dali::Toolkit::Model3dView *arg2 = 0 ;
62744   Dali::Toolkit::Model3dView *result = 0 ;
62745
62746   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62747   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
62748   if (!arg2) {
62749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
62750     return 0;
62751   }
62752   {
62753     try {
62754       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
62755     } catch (std::out_of_range& e) {
62756       {
62757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62758       };
62759     } catch (std::exception& e) {
62760       {
62761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62762       };
62763     } catch (...) {
62764       {
62765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62766       };
62767     }
62768   }
62769   jresult = (void *)result;
62770   return jresult;
62771 }
62772
62773
62774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
62775   void * jresult ;
62776   Dali::BaseHandle arg1 ;
62777   Dali::BaseHandle *argp1 ;
62778   Dali::Toolkit::Model3dView result;
62779
62780   argp1 = (Dali::BaseHandle *)jarg1;
62781   if (!argp1) {
62782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62783     return 0;
62784   }
62785   arg1 = *argp1;
62786   {
62787     try {
62788       result = Dali::Toolkit::Model3dView::DownCast(arg1);
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::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62804   return jresult;
62805 }
62806
62807
62808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
62809   int jresult ;
62810   int result;
62811
62812   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
62813   jresult = (int)result;
62814   return jresult;
62815 }
62816
62817
62818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
62819   int jresult ;
62820   int result;
62821
62822   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
62823   jresult = (int)result;
62824   return jresult;
62825 }
62826
62827
62828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
62829   int jresult ;
62830   int result;
62831
62832   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
62833   jresult = (int)result;
62834   return jresult;
62835 }
62836
62837
62838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
62839   int jresult ;
62840   int result;
62841
62842   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
62843   jresult = (int)result;
62844   return jresult;
62845 }
62846
62847
62848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
62849   int jresult ;
62850   int result;
62851
62852   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
62853   jresult = (int)result;
62854   return jresult;
62855 }
62856
62857
62858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
62859   int jresult ;
62860   int result;
62861
62862   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
62863   jresult = (int)result;
62864   return jresult;
62865 }
62866
62867
62868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
62869   int jresult ;
62870   int result;
62871
62872   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
62873   jresult = (int)result;
62874   return jresult;
62875 }
62876
62877
62878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
62879   int jresult ;
62880   int result;
62881
62882   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
62883   jresult = (int)result;
62884   return jresult;
62885 }
62886
62887
62888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
62889   int jresult ;
62890   int result;
62891
62892   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
62893   jresult = (int)result;
62894   return jresult;
62895 }
62896
62897
62898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
62899   void * jresult ;
62900   Dali::Toolkit::ScrollBar::Property *result = 0 ;
62901
62902   {
62903     try {
62904       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
62905     } catch (std::out_of_range& e) {
62906       {
62907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62908       };
62909     } catch (std::exception& e) {
62910       {
62911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62912       };
62913     } catch (...) {
62914       {
62915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62916       };
62917     }
62918   }
62919   jresult = (void *)result;
62920   return jresult;
62921 }
62922
62923
62924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
62925   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
62926
62927   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
62928   {
62929     try {
62930       delete arg1;
62931     } catch (std::out_of_range& e) {
62932       {
62933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62934       };
62935     } catch (std::exception& e) {
62936       {
62937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62938       };
62939     } catch (...) {
62940       {
62941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62942       };
62943     }
62944   }
62945 }
62946
62947
62948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
62949   void * jresult ;
62950   Dali::Toolkit::ScrollBar *result = 0 ;
62951
62952   {
62953     try {
62954       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
62955     } catch (std::out_of_range& e) {
62956       {
62957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62958       };
62959     } catch (std::exception& e) {
62960       {
62961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62962       };
62963     } catch (...) {
62964       {
62965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62966       };
62967     }
62968   }
62969   jresult = (void *)result;
62970   return jresult;
62971 }
62972
62973
62974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
62975   void * jresult ;
62976   Dali::Toolkit::ScrollBar *arg1 = 0 ;
62977   Dali::Toolkit::ScrollBar *result = 0 ;
62978
62979   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
62980   if (!arg1) {
62981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
62982     return 0;
62983   }
62984   {
62985     try {
62986       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
62987     } catch (std::out_of_range& e) {
62988       {
62989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62990       };
62991     } catch (std::exception& e) {
62992       {
62993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62994       };
62995     } catch (...) {
62996       {
62997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62998       };
62999     }
63000   }
63001   jresult = (void *)result;
63002   return jresult;
63003 }
63004
63005
63006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
63007   void * jresult ;
63008   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63009   Dali::Toolkit::ScrollBar *arg2 = 0 ;
63010   Dali::Toolkit::ScrollBar *result = 0 ;
63011
63012   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63013   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
63014   if (!arg2) {
63015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
63016     return 0;
63017   }
63018   {
63019     try {
63020       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
63021     } catch (std::out_of_range& e) {
63022       {
63023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63024       };
63025     } catch (std::exception& e) {
63026       {
63027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63028       };
63029     } catch (...) {
63030       {
63031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63032       };
63033     }
63034   }
63035   jresult = (void *)result;
63036   return jresult;
63037 }
63038
63039
63040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
63041   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63042
63043   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63044   {
63045     try {
63046       delete arg1;
63047     } catch (std::out_of_range& e) {
63048       {
63049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63050       };
63051     } catch (std::exception& e) {
63052       {
63053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63054       };
63055     } catch (...) {
63056       {
63057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63058       };
63059     }
63060   }
63061 }
63062
63063
63064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
63065   void * jresult ;
63066   Dali::Toolkit::ScrollBar::Direction arg1 ;
63067   Dali::Toolkit::ScrollBar result;
63068
63069   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
63070   {
63071     try {
63072       result = Dali::Toolkit::ScrollBar::New(arg1);
63073     } catch (std::out_of_range& e) {
63074       {
63075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63076       };
63077     } catch (std::exception& e) {
63078       {
63079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63080       };
63081     } catch (...) {
63082       {
63083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63084       };
63085     }
63086   }
63087   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63088   return jresult;
63089 }
63090
63091
63092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
63093   void * jresult ;
63094   Dali::Toolkit::ScrollBar result;
63095
63096   {
63097     try {
63098       result = Dali::Toolkit::ScrollBar::New();
63099     } catch (std::out_of_range& e) {
63100       {
63101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63102       };
63103     } catch (std::exception& e) {
63104       {
63105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63106       };
63107     } catch (...) {
63108       {
63109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63110       };
63111     }
63112   }
63113   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63114   return jresult;
63115 }
63116
63117
63118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
63119   void * jresult ;
63120   Dali::BaseHandle arg1 ;
63121   Dali::BaseHandle *argp1 ;
63122   Dali::Toolkit::ScrollBar result;
63123
63124   argp1 = (Dali::BaseHandle *)jarg1;
63125   if (!argp1) {
63126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63127     return 0;
63128   }
63129   arg1 = *argp1;
63130   {
63131     try {
63132       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
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 = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63148   return jresult;
63149 }
63150
63151
63152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
63153   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63154   Dali::Handle arg2 ;
63155   Dali::Property::Index arg3 ;
63156   Dali::Property::Index arg4 ;
63157   Dali::Property::Index arg5 ;
63158   Dali::Property::Index arg6 ;
63159   Dali::Handle *argp2 ;
63160
63161   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63162   argp2 = (Dali::Handle *)jarg2;
63163   if (!argp2) {
63164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
63165     return ;
63166   }
63167   arg2 = *argp2;
63168   arg3 = (Dali::Property::Index)jarg3;
63169   arg4 = (Dali::Property::Index)jarg4;
63170   arg5 = (Dali::Property::Index)jarg5;
63171   arg6 = (Dali::Property::Index)jarg6;
63172   {
63173     try {
63174       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
63175     } catch (std::out_of_range& e) {
63176       {
63177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63178       };
63179     } catch (std::exception& e) {
63180       {
63181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63182       };
63183     } catch (...) {
63184       {
63185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63186       };
63187     }
63188   }
63189 }
63190
63191
63192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
63193   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63194   Dali::Actor arg2 ;
63195   Dali::Actor *argp2 ;
63196
63197   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63198   argp2 = (Dali::Actor *)jarg2;
63199   if (!argp2) {
63200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63201     return ;
63202   }
63203   arg2 = *argp2;
63204   {
63205     try {
63206       (arg1)->SetScrollIndicator(arg2);
63207     } catch (std::out_of_range& e) {
63208       {
63209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63210       };
63211     } catch (std::exception& e) {
63212       {
63213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63214       };
63215     } catch (...) {
63216       {
63217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63218       };
63219     }
63220   }
63221 }
63222
63223
63224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
63225   void * jresult ;
63226   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63227   Dali::Actor result;
63228
63229   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63230   {
63231     try {
63232       result = (arg1)->GetScrollIndicator();
63233     } catch (std::out_of_range& e) {
63234       {
63235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63236       };
63237     } catch (std::exception& e) {
63238       {
63239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63240       };
63241     } catch (...) {
63242       {
63243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63244       };
63245     }
63246   }
63247   jresult = new Dali::Actor((const Dali::Actor &)result);
63248   return jresult;
63249 }
63250
63251
63252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
63253   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63254   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
63255
63256   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63257   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
63258   if (!arg2) {
63259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
63260     return ;
63261   }
63262   {
63263     try {
63264       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
63265     } catch (std::out_of_range& e) {
63266       {
63267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63268       };
63269     } catch (std::exception& e) {
63270       {
63271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63272       };
63273     } catch (...) {
63274       {
63275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63276       };
63277     }
63278   }
63279 }
63280
63281
63282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
63283   void * jresult ;
63284   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63285   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
63286
63287   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63288   {
63289     try {
63290       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
63291     } catch (std::out_of_range& e) {
63292       {
63293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63294       };
63295     } catch (std::exception& e) {
63296       {
63297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63298       };
63299     } catch (...) {
63300       {
63301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63302       };
63303     }
63304   }
63305   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
63306   return jresult;
63307 }
63308
63309
63310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
63311   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63312   Dali::Toolkit::ScrollBar::Direction arg2 ;
63313
63314   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63315   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
63316   {
63317     try {
63318       (arg1)->SetScrollDirection(arg2);
63319     } catch (std::out_of_range& e) {
63320       {
63321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63322       };
63323     } catch (std::exception& e) {
63324       {
63325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63326       };
63327     } catch (...) {
63328       {
63329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63330       };
63331     }
63332   }
63333 }
63334
63335
63336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
63337   int jresult ;
63338   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63339   Dali::Toolkit::ScrollBar::Direction result;
63340
63341   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63342   {
63343     try {
63344       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
63345     } catch (std::out_of_range& e) {
63346       {
63347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63348       };
63349     } catch (std::exception& e) {
63350       {
63351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63352       };
63353     } catch (...) {
63354       {
63355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63356       };
63357     }
63358   }
63359   jresult = (int)result;
63360   return jresult;
63361 }
63362
63363
63364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
63365   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63366   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
63367
63368   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63369   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
63370   {
63371     try {
63372       (arg1)->SetIndicatorHeightPolicy(arg2);
63373     } catch (std::out_of_range& e) {
63374       {
63375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63376       };
63377     } catch (std::exception& e) {
63378       {
63379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63380       };
63381     } catch (...) {
63382       {
63383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63384       };
63385     }
63386   }
63387 }
63388
63389
63390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
63391   int jresult ;
63392   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63393   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
63394
63395   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63396   {
63397     try {
63398       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
63399     } catch (std::out_of_range& e) {
63400       {
63401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63402       };
63403     } catch (std::exception& e) {
63404       {
63405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63406       };
63407     } catch (...) {
63408       {
63409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63410       };
63411     }
63412   }
63413   jresult = (int)result;
63414   return jresult;
63415 }
63416
63417
63418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
63419   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63420   float arg2 ;
63421
63422   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63423   arg2 = (float)jarg2;
63424   {
63425     try {
63426       (arg1)->SetIndicatorFixedHeight(arg2);
63427     } catch (std::out_of_range& e) {
63428       {
63429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63430       };
63431     } catch (std::exception& e) {
63432       {
63433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63434       };
63435     } catch (...) {
63436       {
63437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63438       };
63439     }
63440   }
63441 }
63442
63443
63444 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
63445   float jresult ;
63446   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63447   float result;
63448
63449   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63450   {
63451     try {
63452       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
63453     } catch (std::out_of_range& e) {
63454       {
63455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63456       };
63457     } catch (std::exception& e) {
63458       {
63459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63460       };
63461     } catch (...) {
63462       {
63463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63464       };
63465     }
63466   }
63467   jresult = result;
63468   return jresult;
63469 }
63470
63471
63472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
63473   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63474   float arg2 ;
63475
63476   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63477   arg2 = (float)jarg2;
63478   {
63479     try {
63480       (arg1)->SetIndicatorShowDuration(arg2);
63481     } catch (std::out_of_range& e) {
63482       {
63483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63484       };
63485     } catch (std::exception& e) {
63486       {
63487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63488       };
63489     } catch (...) {
63490       {
63491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63492       };
63493     }
63494   }
63495 }
63496
63497
63498 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
63499   float jresult ;
63500   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63501   float result;
63502
63503   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63504   {
63505     try {
63506       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
63507     } catch (std::out_of_range& e) {
63508       {
63509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63510       };
63511     } catch (std::exception& e) {
63512       {
63513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63514       };
63515     } catch (...) {
63516       {
63517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63518       };
63519     }
63520   }
63521   jresult = result;
63522   return jresult;
63523 }
63524
63525
63526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
63527   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63528   float arg2 ;
63529
63530   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63531   arg2 = (float)jarg2;
63532   {
63533     try {
63534       (arg1)->SetIndicatorHideDuration(arg2);
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 float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
63553   float jresult ;
63554   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63555   float result;
63556
63557   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63558   {
63559     try {
63560       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
63561     } catch (std::out_of_range& e) {
63562       {
63563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63564       };
63565     } catch (std::exception& e) {
63566       {
63567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63568       };
63569     } catch (...) {
63570       {
63571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63572       };
63573     }
63574   }
63575   jresult = result;
63576   return jresult;
63577 }
63578
63579
63580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
63581   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63582
63583   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63584   {
63585     try {
63586       (arg1)->ShowIndicator();
63587     } catch (std::out_of_range& e) {
63588       {
63589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63590       };
63591     } catch (std::exception& e) {
63592       {
63593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63594       };
63595     } catch (...) {
63596       {
63597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63598       };
63599     }
63600   }
63601 }
63602
63603
63604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
63605   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63606
63607   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63608   {
63609     try {
63610       (arg1)->HideIndicator();
63611     } catch (std::out_of_range& e) {
63612       {
63613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63614       };
63615     } catch (std::exception& e) {
63616       {
63617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63618       };
63619     } catch (...) {
63620       {
63621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63622       };
63623     }
63624   }
63625 }
63626
63627
63628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
63629   void * jresult ;
63630   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63631   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
63632
63633   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63634   {
63635     try {
63636       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
63637     } catch (std::out_of_range& e) {
63638       {
63639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63640       };
63641     } catch (std::exception& e) {
63642       {
63643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63644       };
63645     } catch (...) {
63646       {
63647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63648       };
63649     }
63650   }
63651   jresult = (void *)result;
63652   return jresult;
63653 }
63654
63655
63656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
63657   void * jresult ;
63658   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63659   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
63660
63661   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63662   {
63663     try {
63664       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
63665     } catch (std::out_of_range& e) {
63666       {
63667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63668       };
63669     } catch (std::exception& e) {
63670       {
63671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63672       };
63673     } catch (...) {
63674       {
63675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63676       };
63677     }
63678   }
63679   jresult = (void *)result;
63680   return jresult;
63681 }
63682
63683
63684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
63685   int jresult ;
63686   int result;
63687
63688   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
63689   jresult = (int)result;
63690   return jresult;
63691 }
63692
63693
63694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
63695   int jresult ;
63696   int result;
63697
63698   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
63699   jresult = (int)result;
63700   return jresult;
63701 }
63702
63703
63704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
63705   int jresult ;
63706   int result;
63707
63708   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
63709   jresult = (int)result;
63710   return jresult;
63711 }
63712
63713
63714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
63715   int jresult ;
63716   int result;
63717
63718   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
63719   jresult = (int)result;
63720   return jresult;
63721 }
63722
63723
63724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
63725   int jresult ;
63726   int result;
63727
63728   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
63729   jresult = (int)result;
63730   return jresult;
63731 }
63732
63733
63734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
63735   int jresult ;
63736   int result;
63737
63738   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
63739   jresult = (int)result;
63740   return jresult;
63741 }
63742
63743
63744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
63745   int jresult ;
63746   int result;
63747
63748   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
63749   jresult = (int)result;
63750   return jresult;
63751 }
63752
63753
63754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
63755   int jresult ;
63756   int result;
63757
63758   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
63759   jresult = (int)result;
63760   return jresult;
63761 }
63762
63763
63764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
63765   int jresult ;
63766   int result;
63767
63768   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
63769   jresult = (int)result;
63770   return jresult;
63771 }
63772
63773
63774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
63775   int jresult ;
63776   int result;
63777
63778   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
63779   jresult = (int)result;
63780   return jresult;
63781 }
63782
63783
63784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
63785   int jresult ;
63786   int result;
63787
63788   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
63789   jresult = (int)result;
63790   return jresult;
63791 }
63792
63793
63794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
63795   int jresult ;
63796   int result;
63797
63798   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
63799   jresult = (int)result;
63800   return jresult;
63801 }
63802
63803
63804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
63805   int jresult ;
63806   int result;
63807
63808   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
63809   jresult = (int)result;
63810   return jresult;
63811 }
63812
63813
63814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
63815   int jresult ;
63816   int result;
63817
63818   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
63819   jresult = (int)result;
63820   return jresult;
63821 }
63822
63823
63824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
63825   void * jresult ;
63826   Dali::Toolkit::Scrollable::Property *result = 0 ;
63827
63828   {
63829     try {
63830       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
63831     } catch (std::out_of_range& e) {
63832       {
63833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63834       };
63835     } catch (std::exception& e) {
63836       {
63837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63838       };
63839     } catch (...) {
63840       {
63841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63842       };
63843     }
63844   }
63845   jresult = (void *)result;
63846   return jresult;
63847 }
63848
63849
63850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
63851   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
63852
63853   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
63854   {
63855     try {
63856       delete arg1;
63857     } catch (std::out_of_range& e) {
63858       {
63859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63860       };
63861     } catch (std::exception& e) {
63862       {
63863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63864       };
63865     } catch (...) {
63866       {
63867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63868       };
63869     }
63870   }
63871 }
63872
63873
63874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
63875   void * jresult ;
63876   Dali::Toolkit::Scrollable *result = 0 ;
63877
63878   {
63879     try {
63880       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
63881     } catch (std::out_of_range& e) {
63882       {
63883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63884       };
63885     } catch (std::exception& e) {
63886       {
63887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63888       };
63889     } catch (...) {
63890       {
63891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63892       };
63893     }
63894   }
63895   jresult = (void *)result;
63896   return jresult;
63897 }
63898
63899
63900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
63901   void * jresult ;
63902   Dali::Toolkit::Scrollable *arg1 = 0 ;
63903   Dali::Toolkit::Scrollable *result = 0 ;
63904
63905   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
63906   if (!arg1) {
63907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
63908     return 0;
63909   }
63910   {
63911     try {
63912       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
63913     } catch (std::out_of_range& e) {
63914       {
63915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63916       };
63917     } catch (std::exception& e) {
63918       {
63919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63920       };
63921     } catch (...) {
63922       {
63923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63924       };
63925     }
63926   }
63927   jresult = (void *)result;
63928   return jresult;
63929 }
63930
63931
63932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
63933   void * jresult ;
63934   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
63935   Dali::Toolkit::Scrollable *arg2 = 0 ;
63936   Dali::Toolkit::Scrollable *result = 0 ;
63937
63938   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
63939   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
63940   if (!arg2) {
63941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
63942     return 0;
63943   }
63944   {
63945     try {
63946       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
63947     } catch (std::out_of_range& e) {
63948       {
63949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63950       };
63951     } catch (std::exception& e) {
63952       {
63953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63954       };
63955     } catch (...) {
63956       {
63957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63958       };
63959     }
63960   }
63961   jresult = (void *)result;
63962   return jresult;
63963 }
63964
63965
63966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
63967   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
63968
63969   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
63970   {
63971     try {
63972       delete arg1;
63973     } catch (std::out_of_range& e) {
63974       {
63975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63976       };
63977     } catch (std::exception& e) {
63978       {
63979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63980       };
63981     } catch (...) {
63982       {
63983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63984       };
63985     }
63986   }
63987 }
63988
63989
63990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
63991   void * jresult ;
63992   Dali::BaseHandle arg1 ;
63993   Dali::BaseHandle *argp1 ;
63994   Dali::Toolkit::Scrollable result;
63995
63996   argp1 = (Dali::BaseHandle *)jarg1;
63997   if (!argp1) {
63998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63999     return 0;
64000   }
64001   arg1 = *argp1;
64002   {
64003     try {
64004       result = Dali::Toolkit::Scrollable::DownCast(arg1);
64005     } catch (std::out_of_range& e) {
64006       {
64007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64008       };
64009     } catch (std::exception& e) {
64010       {
64011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64012       };
64013     } catch (...) {
64014       {
64015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64016       };
64017     }
64018   }
64019   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
64020   return jresult;
64021 }
64022
64023
64024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
64025   unsigned int jresult ;
64026   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64027   bool result;
64028
64029   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64030   {
64031     try {
64032       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
64033     } catch (std::out_of_range& e) {
64034       {
64035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64036       };
64037     } catch (std::exception& e) {
64038       {
64039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64040       };
64041     } catch (...) {
64042       {
64043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64044       };
64045     }
64046   }
64047   jresult = result;
64048   return jresult;
64049 }
64050
64051
64052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
64053   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64054   bool arg2 ;
64055
64056   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64057   arg2 = jarg2 ? true : false;
64058   {
64059     try {
64060       (arg1)->SetOvershootEnabled(arg2);
64061     } catch (std::out_of_range& e) {
64062       {
64063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64064       };
64065     } catch (std::exception& e) {
64066       {
64067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64068       };
64069     } catch (...) {
64070       {
64071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64072       };
64073     }
64074   }
64075 }
64076
64077
64078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
64079   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64080   Dali::Vector4 *arg2 = 0 ;
64081
64082   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64083   arg2 = (Dali::Vector4 *)jarg2;
64084   if (!arg2) {
64085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
64086     return ;
64087   }
64088   {
64089     try {
64090       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
64091     } catch (std::out_of_range& e) {
64092       {
64093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64094       };
64095     } catch (std::exception& e) {
64096       {
64097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64098       };
64099     } catch (...) {
64100       {
64101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64102       };
64103     }
64104   }
64105 }
64106
64107
64108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
64109   void * jresult ;
64110   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64111   Dali::Vector4 result;
64112
64113   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64114   {
64115     try {
64116       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
64117     } catch (std::out_of_range& e) {
64118       {
64119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64120       };
64121     } catch (std::exception& e) {
64122       {
64123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64124       };
64125     } catch (...) {
64126       {
64127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64128       };
64129     }
64130   }
64131   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
64132   return jresult;
64133 }
64134
64135
64136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
64137   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64138   float arg2 ;
64139
64140   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64141   arg2 = (float)jarg2;
64142   {
64143     try {
64144       (arg1)->SetOvershootAnimationSpeed(arg2);
64145     } catch (std::out_of_range& e) {
64146       {
64147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64148       };
64149     } catch (std::exception& e) {
64150       {
64151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64152       };
64153     } catch (...) {
64154       {
64155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64156       };
64157     }
64158   }
64159 }
64160
64161
64162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
64163   float jresult ;
64164   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64165   float result;
64166
64167   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64168   {
64169     try {
64170       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
64171     } catch (std::out_of_range& e) {
64172       {
64173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64174       };
64175     } catch (std::exception& e) {
64176       {
64177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64178       };
64179     } catch (...) {
64180       {
64181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64182       };
64183     }
64184   }
64185   jresult = result;
64186   return jresult;
64187 }
64188
64189
64190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
64191   void * jresult ;
64192   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64193   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
64194
64195   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64196   {
64197     try {
64198       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
64199     } catch (std::out_of_range& e) {
64200       {
64201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64202       };
64203     } catch (std::exception& e) {
64204       {
64205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64206       };
64207     } catch (...) {
64208       {
64209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64210       };
64211     }
64212   }
64213   jresult = (void *)result;
64214   return jresult;
64215 }
64216
64217
64218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
64219   void * jresult ;
64220   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64221   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
64222
64223   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64224   {
64225     try {
64226       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
64227     } catch (std::out_of_range& e) {
64228       {
64229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64230       };
64231     } catch (std::exception& e) {
64232       {
64233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64234       };
64235     } catch (...) {
64236       {
64237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64238       };
64239     }
64240   }
64241   jresult = (void *)result;
64242   return jresult;
64243 }
64244
64245
64246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
64247   void * jresult ;
64248   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64249   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
64250
64251   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64252   {
64253     try {
64254       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
64255     } catch (std::out_of_range& e) {
64256       {
64257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64258       };
64259     } catch (std::exception& e) {
64260       {
64261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64262       };
64263     } catch (...) {
64264       {
64265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64266       };
64267     }
64268   }
64269   jresult = (void *)result;
64270   return jresult;
64271 }
64272
64273
64274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
64275   unsigned int jresult ;
64276   Dali::Toolkit::ControlOrientation::Type arg1 ;
64277   bool result;
64278
64279   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
64280   {
64281     try {
64282       result = (bool)Dali::Toolkit::IsVertical(arg1);
64283     } catch (std::out_of_range& e) {
64284       {
64285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64286       };
64287     } catch (std::exception& e) {
64288       {
64289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64290       };
64291     } catch (...) {
64292       {
64293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64294       };
64295     }
64296   }
64297   jresult = result;
64298   return jresult;
64299 }
64300
64301
64302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
64303   unsigned int jresult ;
64304   Dali::Toolkit::ControlOrientation::Type arg1 ;
64305   bool result;
64306
64307   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
64308   {
64309     try {
64310       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
64311     } catch (std::out_of_range& e) {
64312       {
64313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64314       };
64315     } catch (std::exception& e) {
64316       {
64317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64318       };
64319     } catch (...) {
64320       {
64321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64322       };
64323     }
64324   }
64325   jresult = result;
64326   return jresult;
64327 }
64328
64329
64330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
64331   void * jresult ;
64332   unsigned int arg1 ;
64333   unsigned int arg2 ;
64334   Dali::Toolkit::ItemRange *result = 0 ;
64335
64336   arg1 = (unsigned int)jarg1;
64337   arg2 = (unsigned int)jarg2;
64338   {
64339     try {
64340       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
64341     } catch (std::out_of_range& e) {
64342       {
64343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64344       };
64345     } catch (std::exception& e) {
64346       {
64347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64348       };
64349     } catch (...) {
64350       {
64351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64352       };
64353     }
64354   }
64355   jresult = (void *)result;
64356   return jresult;
64357 }
64358
64359
64360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
64361   void * jresult ;
64362   Dali::Toolkit::ItemRange *arg1 = 0 ;
64363   Dali::Toolkit::ItemRange *result = 0 ;
64364
64365   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64366   if (!arg1) {
64367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64368     return 0;
64369   }
64370   {
64371     try {
64372       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
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 = (void *)result;
64388   return jresult;
64389 }
64390
64391
64392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
64393   void * jresult ;
64394   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64395   Dali::Toolkit::ItemRange *arg2 = 0 ;
64396   Dali::Toolkit::ItemRange *result = 0 ;
64397
64398   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64399   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
64400   if (!arg2) {
64401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64402     return 0;
64403   }
64404   {
64405     try {
64406       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
64407     } catch (std::out_of_range& e) {
64408       {
64409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64410       };
64411     } catch (std::exception& e) {
64412       {
64413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64414       };
64415     } catch (...) {
64416       {
64417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64418       };
64419     }
64420   }
64421   jresult = (void *)result;
64422   return jresult;
64423 }
64424
64425
64426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
64427   unsigned int jresult ;
64428   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64429   unsigned int arg2 ;
64430   bool result;
64431
64432   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64433   arg2 = (unsigned int)jarg2;
64434   {
64435     try {
64436       result = (bool)(arg1)->Within(arg2);
64437     } catch (std::out_of_range& e) {
64438       {
64439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64440       };
64441     } catch (std::exception& e) {
64442       {
64443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64444       };
64445     } catch (...) {
64446       {
64447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64448       };
64449     }
64450   }
64451   jresult = result;
64452   return jresult;
64453 }
64454
64455
64456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
64457   void * jresult ;
64458   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64459   Dali::Toolkit::ItemRange *arg2 = 0 ;
64460   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
64461
64462   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64463   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
64464   if (!arg2) {
64465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64466     return 0;
64467   }
64468   {
64469     try {
64470       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
64471     } catch (std::out_of_range& e) {
64472       {
64473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64474       };
64475     } catch (std::exception& e) {
64476       {
64477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64478       };
64479     } catch (...) {
64480       {
64481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64482       };
64483     }
64484   }
64485   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
64486   return jresult;
64487 }
64488
64489
64490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
64491   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64492   unsigned int arg2 ;
64493
64494   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64495   arg2 = (unsigned int)jarg2;
64496   if (arg1) (arg1)->begin = arg2;
64497 }
64498
64499
64500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
64501   unsigned int jresult ;
64502   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64503   unsigned int result;
64504
64505   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64506   result = (unsigned int) ((arg1)->begin);
64507   jresult = result;
64508   return jresult;
64509 }
64510
64511
64512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
64513   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64514   unsigned int arg2 ;
64515
64516   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64517   arg2 = (unsigned int)jarg2;
64518   if (arg1) (arg1)->end = arg2;
64519 }
64520
64521
64522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
64523   unsigned int jresult ;
64524   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64525   unsigned int result;
64526
64527   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64528   result = (unsigned int) ((arg1)->end);
64529   jresult = result;
64530   return jresult;
64531 }
64532
64533
64534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
64535   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64536
64537   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64538   {
64539     try {
64540       delete arg1;
64541     } catch (std::out_of_range& e) {
64542       {
64543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64544       };
64545     } catch (std::exception& e) {
64546       {
64547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64548       };
64549     } catch (...) {
64550       {
64551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64552       };
64553     }
64554   }
64555 }
64556
64557
64558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
64559   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64560
64561   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64562   {
64563     try {
64564       delete arg1;
64565     } catch (std::out_of_range& e) {
64566       {
64567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64568       };
64569     } catch (std::exception& e) {
64570       {
64571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64572       };
64573     } catch (...) {
64574       {
64575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64576       };
64577     }
64578   }
64579 }
64580
64581
64582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
64583   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64584   Dali::Toolkit::ControlOrientation::Type arg2 ;
64585
64586   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64587   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
64588   {
64589     try {
64590       (arg1)->SetOrientation(arg2);
64591     } catch (std::out_of_range& e) {
64592       {
64593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64594       };
64595     } catch (std::exception& e) {
64596       {
64597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64598       };
64599     } catch (...) {
64600       {
64601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64602       };
64603     }
64604   }
64605 }
64606
64607
64608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
64609   int jresult ;
64610   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64611   Dali::Toolkit::ControlOrientation::Type result;
64612
64613   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64614   {
64615     try {
64616       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
64617     } catch (std::out_of_range& e) {
64618       {
64619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64620       };
64621     } catch (std::exception& e) {
64622       {
64623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64624       };
64625     } catch (...) {
64626       {
64627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64628       };
64629     }
64630   }
64631   jresult = (int)result;
64632   return jresult;
64633 }
64634
64635
64636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
64637   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64638   Dali::Property::Map *arg2 = 0 ;
64639
64640   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64641   arg2 = (Dali::Property::Map *)jarg2;
64642   if (!arg2) {
64643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
64644     return ;
64645   }
64646   {
64647     try {
64648       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
64649     } catch (std::out_of_range& e) {
64650       {
64651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64652       };
64653     } catch (std::exception& e) {
64654       {
64655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64656       };
64657     } catch (...) {
64658       {
64659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64660       };
64661     }
64662   }
64663 }
64664
64665
64666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
64667   void * jresult ;
64668   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64669   Dali::Property::Map result;
64670
64671   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64672   {
64673     try {
64674       result = (arg1)->GetLayoutProperties();
64675     } catch (std::out_of_range& e) {
64676       {
64677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64678       };
64679     } catch (std::exception& e) {
64680       {
64681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64682       };
64683     } catch (...) {
64684       {
64685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64686       };
64687     }
64688   }
64689   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
64690   return jresult;
64691 }
64692
64693
64694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
64695   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64696   unsigned int arg2 ;
64697   Dali::Vector3 *arg3 = 0 ;
64698   Dali::Vector3 *arg4 = 0 ;
64699
64700   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64701   arg2 = (unsigned int)jarg2;
64702   arg3 = (Dali::Vector3 *)jarg3;
64703   if (!arg3) {
64704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64705     return ;
64706   }
64707   arg4 = (Dali::Vector3 *)jarg4;
64708   if (!arg4) {
64709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
64710     return ;
64711   }
64712   {
64713     try {
64714       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
64715     } catch (std::out_of_range& e) {
64716       {
64717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64718       };
64719     } catch (std::exception& e) {
64720       {
64721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64722       };
64723     } catch (...) {
64724       {
64725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64726       };
64727     }
64728   }
64729 }
64730
64731
64732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
64733   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64734   Dali::Vector3 *arg2 = 0 ;
64735
64736   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64737   arg2 = (Dali::Vector3 *)jarg2;
64738   if (!arg2) {
64739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64740     return ;
64741   }
64742   {
64743     try {
64744       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
64745     } catch (std::out_of_range& e) {
64746       {
64747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64748       };
64749     } catch (std::exception& e) {
64750       {
64751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64752       };
64753     } catch (...) {
64754       {
64755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64756       };
64757     }
64758   }
64759 }
64760
64761
64762 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
64763   float jresult ;
64764   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64765   unsigned int arg2 ;
64766   Dali::Vector3 arg3 ;
64767   Dali::Vector3 *argp3 ;
64768   float result;
64769
64770   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64771   arg2 = (unsigned int)jarg2;
64772   argp3 = (Dali::Vector3 *)jarg3;
64773   if (!argp3) {
64774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
64775     return 0;
64776   }
64777   arg3 = *argp3;
64778   {
64779     try {
64780       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
64781     } catch (std::out_of_range& e) {
64782       {
64783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64784       };
64785     } catch (std::exception& e) {
64786       {
64787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64788       };
64789     } catch (...) {
64790       {
64791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64792       };
64793     }
64794   }
64795   jresult = result;
64796   return jresult;
64797 }
64798
64799
64800 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
64801   float jresult ;
64802   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64803   float arg2 ;
64804   float result;
64805
64806   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64807   arg2 = (float)jarg2;
64808   {
64809     try {
64810       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
64811     } catch (std::out_of_range& e) {
64812       {
64813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64814       };
64815     } catch (std::exception& e) {
64816       {
64817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64818       };
64819     } catch (...) {
64820       {
64821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64822       };
64823     }
64824   }
64825   jresult = result;
64826   return jresult;
64827 }
64828
64829
64830 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
64831   float jresult ;
64832   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64833   unsigned int arg2 ;
64834   float result;
64835
64836   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64837   arg2 = (unsigned int)jarg2;
64838   {
64839     try {
64840       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
64841     } catch (std::out_of_range& e) {
64842       {
64843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64844       };
64845     } catch (std::exception& e) {
64846       {
64847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64848       };
64849     } catch (...) {
64850       {
64851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64852       };
64853     }
64854   }
64855   jresult = result;
64856   return jresult;
64857 }
64858
64859
64860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
64861   void * jresult ;
64862   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64863   float arg2 ;
64864   Dali::Vector3 arg3 ;
64865   Dali::Vector3 *argp3 ;
64866   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
64867
64868   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64869   arg2 = (float)jarg2;
64870   argp3 = (Dali::Vector3 *)jarg3;
64871   if (!argp3) {
64872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
64873     return 0;
64874   }
64875   arg3 = *argp3;
64876   {
64877     try {
64878       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
64879     } catch (std::out_of_range& e) {
64880       {
64881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64882       };
64883     } catch (std::exception& e) {
64884       {
64885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64886       };
64887     } catch (...) {
64888       {
64889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64890       };
64891     }
64892   }
64893   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
64894   return jresult;
64895 }
64896
64897
64898 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
64899   float jresult ;
64900   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64901   int arg2 ;
64902   float arg3 ;
64903   Dali::Vector3 *arg4 = 0 ;
64904   float result;
64905
64906   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64907   arg2 = (int)jarg2;
64908   arg3 = (float)jarg3;
64909   arg4 = (Dali::Vector3 *)jarg4;
64910   if (!arg4) {
64911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64912     return 0;
64913   }
64914   {
64915     try {
64916       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
64917     } catch (std::out_of_range& e) {
64918       {
64919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64920       };
64921     } catch (std::exception& e) {
64922       {
64923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64924       };
64925     } catch (...) {
64926       {
64927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64928       };
64929     }
64930   }
64931   jresult = result;
64932   return jresult;
64933 }
64934
64935
64936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
64937   unsigned int jresult ;
64938   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64939   Dali::Vector3 arg2 ;
64940   Dali::Vector3 *argp2 ;
64941   unsigned int result;
64942
64943   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64944   argp2 = (Dali::Vector3 *)jarg2;
64945   if (!argp2) {
64946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
64947     return 0;
64948   }
64949   arg2 = *argp2;
64950   {
64951     try {
64952       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
64953     } catch (std::out_of_range& e) {
64954       {
64955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64956       };
64957     } catch (std::exception& e) {
64958       {
64959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64960       };
64961     } catch (...) {
64962       {
64963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64964       };
64965     }
64966   }
64967   jresult = result;
64968   return jresult;
64969 }
64970
64971
64972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
64973   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64974   unsigned int arg2 ;
64975   Dali::Vector3 *arg3 = 0 ;
64976   Dali::Vector3 *arg4 = 0 ;
64977
64978   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64979   arg2 = (unsigned int)jarg2;
64980   arg3 = (Dali::Vector3 *)jarg3;
64981   if (!arg3) {
64982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64983     return ;
64984   }
64985   arg4 = (Dali::Vector3 *)jarg4;
64986   if (!arg4) {
64987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
64988     return ;
64989   }
64990   {
64991     try {
64992       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
64993     } catch (std::out_of_range& e) {
64994       {
64995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64996       };
64997     } catch (std::exception& e) {
64998       {
64999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65000       };
65001     } catch (...) {
65002       {
65003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65004       };
65005     }
65006   }
65007 }
65008
65009
65010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
65011   void * jresult ;
65012   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65013   Dali::Degree result;
65014
65015   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65016   {
65017     try {
65018       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
65019     } catch (std::out_of_range& e) {
65020       {
65021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65022       };
65023     } catch (std::exception& e) {
65024       {
65025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65026       };
65027     } catch (...) {
65028       {
65029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65030       };
65031     }
65032   }
65033   jresult = new Dali::Degree((const Dali::Degree &)result);
65034   return jresult;
65035 }
65036
65037
65038 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
65039   float jresult ;
65040   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65041   float result;
65042
65043   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65044   {
65045     try {
65046       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
65047     } catch (std::out_of_range& e) {
65048       {
65049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65050       };
65051     } catch (std::exception& e) {
65052       {
65053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65054       };
65055     } catch (...) {
65056       {
65057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65058       };
65059     }
65060   }
65061   jresult = result;
65062   return jresult;
65063 }
65064
65065
65066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
65067   float jresult ;
65068   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65069   float result;
65070
65071   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65072   {
65073     try {
65074       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
65075     } catch (std::out_of_range& e) {
65076       {
65077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65078       };
65079     } catch (std::exception& e) {
65080       {
65081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65082       };
65083     } catch (...) {
65084       {
65085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65086       };
65087     }
65088   }
65089   jresult = result;
65090   return jresult;
65091 }
65092
65093
65094 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
65095   float jresult ;
65096   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65097   float result;
65098
65099   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65100   {
65101     try {
65102       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
65103     } catch (std::out_of_range& e) {
65104       {
65105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65106       };
65107     } catch (std::exception& e) {
65108       {
65109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65110       };
65111     } catch (...) {
65112       {
65113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65114       };
65115     }
65116   }
65117   jresult = result;
65118   return jresult;
65119 }
65120
65121
65122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
65123   int jresult ;
65124   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65125   int arg2 ;
65126   int arg3 ;
65127   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
65128   bool arg5 ;
65129   int result;
65130
65131   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65132   arg2 = (int)jarg2;
65133   arg3 = (int)jarg3;
65134   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
65135   arg5 = jarg5 ? true : false;
65136   {
65137     try {
65138       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
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 = result;
65154   return jresult;
65155 }
65156
65157
65158 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
65159   float jresult ;
65160   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65161   float result;
65162
65163   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65164   {
65165     try {
65166       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
65167     } catch (std::out_of_range& e) {
65168       {
65169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65170       };
65171     } catch (std::exception& e) {
65172       {
65173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65174       };
65175     } catch (...) {
65176       {
65177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65178       };
65179     }
65180   }
65181   jresult = result;
65182   return jresult;
65183 }
65184
65185
65186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
65187   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65188   Dali::Actor *arg2 = 0 ;
65189   int arg3 ;
65190   Dali::Vector3 *arg4 = 0 ;
65191   Dali::Actor *arg5 = 0 ;
65192
65193   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65194   arg2 = (Dali::Actor *)jarg2;
65195   if (!arg2) {
65196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65197     return ;
65198   }
65199   arg3 = (int)jarg3;
65200   arg4 = (Dali::Vector3 *)jarg4;
65201   if (!arg4) {
65202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65203     return ;
65204   }
65205   arg5 = (Dali::Actor *)jarg5;
65206   if (!arg5) {
65207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65208     return ;
65209   }
65210   {
65211     try {
65212       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
65213     } catch (std::out_of_range& e) {
65214       {
65215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65216       };
65217     } catch (std::exception& e) {
65218       {
65219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65220       };
65221     } catch (...) {
65222       {
65223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65224       };
65225     }
65226   }
65227 }
65228
65229
65230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
65231   void * jresult ;
65232   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65233   int arg2 ;
65234   float arg3 ;
65235   Dali::Vector3 *arg4 = 0 ;
65236   Dali::Vector3 result;
65237
65238   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65239   arg2 = (int)jarg2;
65240   arg3 = (float)jarg3;
65241   arg4 = (Dali::Vector3 *)jarg4;
65242   if (!arg4) {
65243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65244     return 0;
65245   }
65246   {
65247     try {
65248       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
65249     } catch (std::out_of_range& e) {
65250       {
65251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65252       };
65253     } catch (std::exception& e) {
65254       {
65255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65256       };
65257     } catch (...) {
65258       {
65259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65260       };
65261     }
65262   }
65263   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65264   return jresult;
65265 }
65266
65267
65268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
65269   void * jresult ;
65270   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
65271   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
65272
65273   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
65274   {
65275     try {
65276       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
65277     } catch (std::out_of_range& e) {
65278       {
65279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65280       };
65281     } catch (std::exception& e) {
65282       {
65283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65284       };
65285     } catch (...) {
65286       {
65287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65288       };
65289     }
65290   }
65291   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
65292   return jresult;
65293 }
65294
65295
65296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
65297   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65298
65299   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65300   {
65301     try {
65302       delete arg1;
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 unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
65321   unsigned int jresult ;
65322   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65323   unsigned int result;
65324
65325   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65326   {
65327     try {
65328       result = (unsigned int)(arg1)->GetNumberOfItems();
65329     } catch (std::out_of_range& e) {
65330       {
65331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65332       };
65333     } catch (std::exception& e) {
65334       {
65335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65336       };
65337     } catch (...) {
65338       {
65339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65340       };
65341     }
65342   }
65343   jresult = result;
65344   return jresult;
65345 }
65346
65347
65348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
65349   void * jresult ;
65350   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65351   unsigned int arg2 ;
65352   Dali::Actor result;
65353
65354   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65355   arg2 = (unsigned int)jarg2;
65356   {
65357     try {
65358       result = (arg1)->NewItem(arg2);
65359     } catch (std::out_of_range& e) {
65360       {
65361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65362       };
65363     } catch (std::exception& e) {
65364       {
65365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65366       };
65367     } catch (...) {
65368       {
65369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65370       };
65371     }
65372   }
65373   jresult = new Dali::Actor((const Dali::Actor &)result);
65374   return jresult;
65375 }
65376
65377
65378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
65379   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65380   unsigned int arg2 ;
65381   Dali::Actor arg3 ;
65382   Dali::Actor *argp3 ;
65383
65384   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65385   arg2 = (unsigned int)jarg2;
65386   argp3 = (Dali::Actor *)jarg3;
65387   if (!argp3) {
65388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65389     return ;
65390   }
65391   arg3 = *argp3;
65392   {
65393     try {
65394       (arg1)->ItemReleased(arg2,arg3);
65395     } catch (std::out_of_range& e) {
65396       {
65397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65398       };
65399     } catch (std::exception& e) {
65400       {
65401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65402       };
65403     } catch (...) {
65404       {
65405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65406       };
65407     }
65408   }
65409 }
65410
65411
65412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
65413   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65414   unsigned int arg2 ;
65415   Dali::Actor arg3 ;
65416   Dali::Actor *argp3 ;
65417
65418   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65419   arg2 = (unsigned int)jarg2;
65420   argp3 = (Dali::Actor *)jarg3;
65421   if (!argp3) {
65422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65423     return ;
65424   }
65425   arg3 = *argp3;
65426   {
65427     try {
65428       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
65429     } catch (std::out_of_range& e) {
65430       {
65431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65432       };
65433     } catch (std::exception& e) {
65434       {
65435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65436       };
65437     } catch (...) {
65438       {
65439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65440       };
65441     }
65442   }
65443 }
65444
65445
65446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
65447   void * jresult ;
65448   Dali::Toolkit::ItemFactory *result = 0 ;
65449
65450   {
65451     try {
65452       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
65453     } catch (std::out_of_range& e) {
65454       {
65455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65456       };
65457     } catch (std::exception& e) {
65458       {
65459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65460       };
65461     } catch (...) {
65462       {
65463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65464       };
65465     }
65466   }
65467   jresult = (void *)result;
65468   return jresult;
65469 }
65470
65471
65472 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) {
65473   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
65474   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
65475   if (director) {
65476     director->swig_connect_director(callback0, callback1, callback2);
65477   }
65478 }
65479
65480
65481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
65482   int jresult ;
65483   int result;
65484
65485   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
65486   jresult = (int)result;
65487   return jresult;
65488 }
65489
65490
65491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
65492   int jresult ;
65493   int result;
65494
65495   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
65496   jresult = (int)result;
65497   return jresult;
65498 }
65499
65500
65501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
65502   int jresult ;
65503   int result;
65504
65505   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
65506   jresult = (int)result;
65507   return jresult;
65508 }
65509
65510
65511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
65512   int jresult ;
65513   int result;
65514
65515   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
65516   jresult = (int)result;
65517   return jresult;
65518 }
65519
65520
65521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
65522   int jresult ;
65523   int result;
65524
65525   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
65526   jresult = (int)result;
65527   return jresult;
65528 }
65529
65530
65531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
65532   int jresult ;
65533   int result;
65534
65535   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
65536   jresult = (int)result;
65537   return jresult;
65538 }
65539
65540
65541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
65542   int jresult ;
65543   int result;
65544
65545   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
65546   jresult = (int)result;
65547   return jresult;
65548 }
65549
65550
65551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
65552   int jresult ;
65553   int result;
65554
65555   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
65556   jresult = (int)result;
65557   return jresult;
65558 }
65559
65560
65561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
65562   int jresult ;
65563   int result;
65564
65565   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
65566   jresult = (int)result;
65567   return jresult;
65568 }
65569
65570
65571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
65572   int jresult ;
65573   int result;
65574
65575   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
65576   jresult = (int)result;
65577   return jresult;
65578 }
65579
65580
65581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
65582   int jresult ;
65583   int result;
65584
65585   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
65586   jresult = (int)result;
65587   return jresult;
65588 }
65589
65590
65591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
65592   void * jresult ;
65593   Dali::Toolkit::ItemView::Property *result = 0 ;
65594
65595   {
65596     try {
65597       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
65598     } catch (std::out_of_range& e) {
65599       {
65600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65601       };
65602     } catch (std::exception& e) {
65603       {
65604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65605       };
65606     } catch (...) {
65607       {
65608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65609       };
65610     }
65611   }
65612   jresult = (void *)result;
65613   return jresult;
65614 }
65615
65616
65617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
65618   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
65619
65620   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
65621   {
65622     try {
65623       delete arg1;
65624     } catch (std::out_of_range& e) {
65625       {
65626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65627       };
65628     } catch (std::exception& e) {
65629       {
65630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65631       };
65632     } catch (...) {
65633       {
65634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65635       };
65636     }
65637   }
65638 }
65639
65640
65641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
65642   void * jresult ;
65643   Dali::Toolkit::ItemView *result = 0 ;
65644
65645   {
65646     try {
65647       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
65648     } catch (std::out_of_range& e) {
65649       {
65650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65651       };
65652     } catch (std::exception& e) {
65653       {
65654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65655       };
65656     } catch (...) {
65657       {
65658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65659       };
65660     }
65661   }
65662   jresult = (void *)result;
65663   return jresult;
65664 }
65665
65666
65667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
65668   void * jresult ;
65669   Dali::Toolkit::ItemView *arg1 = 0 ;
65670   Dali::Toolkit::ItemView *result = 0 ;
65671
65672   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65673   if (!arg1) {
65674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
65675     return 0;
65676   }
65677   {
65678     try {
65679       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
65680     } catch (std::out_of_range& e) {
65681       {
65682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65683       };
65684     } catch (std::exception& e) {
65685       {
65686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65687       };
65688     } catch (...) {
65689       {
65690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65691       };
65692     }
65693   }
65694   jresult = (void *)result;
65695   return jresult;
65696 }
65697
65698
65699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
65700   void * jresult ;
65701   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65702   Dali::Toolkit::ItemView *arg2 = 0 ;
65703   Dali::Toolkit::ItemView *result = 0 ;
65704
65705   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65706   arg2 = (Dali::Toolkit::ItemView *)jarg2;
65707   if (!arg2) {
65708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
65709     return 0;
65710   }
65711   {
65712     try {
65713       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
65714     } catch (std::out_of_range& e) {
65715       {
65716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65717       };
65718     } catch (std::exception& e) {
65719       {
65720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65721       };
65722     } catch (...) {
65723       {
65724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65725       };
65726     }
65727   }
65728   jresult = (void *)result;
65729   return jresult;
65730 }
65731
65732
65733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
65734   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65735
65736   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65737   {
65738     try {
65739       delete arg1;
65740     } catch (std::out_of_range& e) {
65741       {
65742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65743       };
65744     } catch (std::exception& e) {
65745       {
65746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65747       };
65748     } catch (...) {
65749       {
65750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65751       };
65752     }
65753   }
65754 }
65755
65756
65757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
65758   void * jresult ;
65759   Dali::Toolkit::ItemFactory *arg1 = 0 ;
65760   Dali::Toolkit::ItemView result;
65761
65762   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65763   if (!arg1) {
65764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
65765     return 0;
65766   }
65767   {
65768     try {
65769       result = Dali::Toolkit::ItemView::New(*arg1);
65770     } catch (std::out_of_range& e) {
65771       {
65772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65773       };
65774     } catch (std::exception& e) {
65775       {
65776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65777       };
65778     } catch (...) {
65779       {
65780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65781       };
65782     }
65783   }
65784   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
65785   return jresult;
65786 }
65787
65788
65789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
65790   void * jresult ;
65791   Dali::BaseHandle arg1 ;
65792   Dali::BaseHandle *argp1 ;
65793   Dali::Toolkit::ItemView result;
65794
65795   argp1 = (Dali::BaseHandle *)jarg1;
65796   if (!argp1) {
65797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65798     return 0;
65799   }
65800   arg1 = *argp1;
65801   {
65802     try {
65803       result = Dali::Toolkit::ItemView::DownCast(arg1);
65804     } catch (std::out_of_range& e) {
65805       {
65806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65807       };
65808     } catch (std::exception& e) {
65809       {
65810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65811       };
65812     } catch (...) {
65813       {
65814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65815       };
65816     }
65817   }
65818   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
65819   return jresult;
65820 }
65821
65822
65823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
65824   unsigned int jresult ;
65825   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65826   unsigned int result;
65827
65828   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65829   {
65830     try {
65831       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
65832     } catch (std::out_of_range& e) {
65833       {
65834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65835       };
65836     } catch (std::exception& e) {
65837       {
65838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65839       };
65840     } catch (...) {
65841       {
65842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65843       };
65844     }
65845   }
65846   jresult = result;
65847   return jresult;
65848 }
65849
65850
65851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
65852   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65853   Dali::Toolkit::ItemLayout *arg2 = 0 ;
65854
65855   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65856   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
65857   if (!arg2) {
65858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
65859     return ;
65860   }
65861   {
65862     try {
65863       (arg1)->AddLayout(*arg2);
65864     } catch (std::out_of_range& e) {
65865       {
65866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65867       };
65868     } catch (std::exception& e) {
65869       {
65870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65871       };
65872     } catch (...) {
65873       {
65874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65875       };
65876     }
65877   }
65878 }
65879
65880
65881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
65882   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65883   unsigned int arg2 ;
65884
65885   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65886   arg2 = (unsigned int)jarg2;
65887   {
65888     try {
65889       (arg1)->RemoveLayout(arg2);
65890     } catch (std::out_of_range& e) {
65891       {
65892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65893       };
65894     } catch (std::exception& e) {
65895       {
65896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65897       };
65898     } catch (...) {
65899       {
65900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65901       };
65902     }
65903   }
65904 }
65905
65906
65907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
65908   void * jresult ;
65909   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65910   unsigned int arg2 ;
65911   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
65912
65913   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65914   arg2 = (unsigned int)jarg2;
65915   {
65916     try {
65917       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
65918     } catch (std::out_of_range& e) {
65919       {
65920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65921       };
65922     } catch (std::exception& e) {
65923       {
65924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65925       };
65926     } catch (...) {
65927       {
65928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65929       };
65930     }
65931   }
65932   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
65933   return jresult;
65934 }
65935
65936
65937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
65938   void * jresult ;
65939   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65940   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
65941
65942   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65943   {
65944     try {
65945       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
65946     } catch (std::out_of_range& e) {
65947       {
65948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65949       };
65950     } catch (std::exception& e) {
65951       {
65952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65953       };
65954     } catch (...) {
65955       {
65956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65957       };
65958     }
65959   }
65960   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
65961   return jresult;
65962 }
65963
65964
65965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
65966   float jresult ;
65967   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65968   Dali::Toolkit::ItemId arg2 ;
65969   float result;
65970
65971   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65972   arg2 = (Dali::Toolkit::ItemId)jarg2;
65973   {
65974     try {
65975       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
65976     } catch (std::out_of_range& e) {
65977       {
65978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65979       };
65980     } catch (std::exception& e) {
65981       {
65982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65983       };
65984     } catch (...) {
65985       {
65986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65987       };
65988     }
65989   }
65990   jresult = result;
65991   return jresult;
65992 }
65993
65994
65995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
65996   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65997   unsigned int arg2 ;
65998   Dali::Vector3 arg3 ;
65999   float arg4 ;
66000   Dali::Vector3 *argp3 ;
66001
66002   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66003   arg2 = (unsigned int)jarg2;
66004   argp3 = (Dali::Vector3 *)jarg3;
66005   if (!argp3) {
66006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
66007     return ;
66008   }
66009   arg3 = *argp3;
66010   arg4 = (float)jarg4;
66011   {
66012     try {
66013       (arg1)->ActivateLayout(arg2,arg3,arg4);
66014     } catch (std::out_of_range& e) {
66015       {
66016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66017       };
66018     } catch (std::exception& e) {
66019       {
66020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66021       };
66022     } catch (...) {
66023       {
66024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66025       };
66026     }
66027   }
66028 }
66029
66030
66031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
66032   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66033
66034   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66035   {
66036     try {
66037       (arg1)->DeactivateCurrentLayout();
66038     } catch (std::out_of_range& e) {
66039       {
66040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66041       };
66042     } catch (std::exception& e) {
66043       {
66044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66045       };
66046     } catch (...) {
66047       {
66048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66049       };
66050     }
66051   }
66052 }
66053
66054
66055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
66056   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66057   float arg2 ;
66058
66059   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66060   arg2 = (float)jarg2;
66061   {
66062     try {
66063       (arg1)->SetMinimumSwipeSpeed(arg2);
66064     } catch (std::out_of_range& e) {
66065       {
66066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66067       };
66068     } catch (std::exception& e) {
66069       {
66070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66071       };
66072     } catch (...) {
66073       {
66074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66075       };
66076     }
66077   }
66078 }
66079
66080
66081 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
66082   float jresult ;
66083   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66084   float result;
66085
66086   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66087   {
66088     try {
66089       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
66090     } catch (std::out_of_range& e) {
66091       {
66092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66093       };
66094     } catch (std::exception& e) {
66095       {
66096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66097       };
66098     } catch (...) {
66099       {
66100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66101       };
66102     }
66103   }
66104   jresult = result;
66105   return jresult;
66106 }
66107
66108
66109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
66110   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66111   float arg2 ;
66112
66113   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66114   arg2 = (float)jarg2;
66115   {
66116     try {
66117       (arg1)->SetMinimumSwipeDistance(arg2);
66118     } catch (std::out_of_range& e) {
66119       {
66120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66121       };
66122     } catch (std::exception& e) {
66123       {
66124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66125       };
66126     } catch (...) {
66127       {
66128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66129       };
66130     }
66131   }
66132 }
66133
66134
66135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
66136   float jresult ;
66137   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66138   float result;
66139
66140   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66141   {
66142     try {
66143       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
66144     } catch (std::out_of_range& e) {
66145       {
66146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66147       };
66148     } catch (std::exception& e) {
66149       {
66150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66151       };
66152     } catch (...) {
66153       {
66154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66155       };
66156     }
66157   }
66158   jresult = result;
66159   return jresult;
66160 }
66161
66162
66163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
66164   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66165   float arg2 ;
66166
66167   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66168   arg2 = (float)jarg2;
66169   {
66170     try {
66171       (arg1)->SetWheelScrollDistanceStep(arg2);
66172     } catch (std::out_of_range& e) {
66173       {
66174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66175       };
66176     } catch (std::exception& e) {
66177       {
66178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66179       };
66180     } catch (...) {
66181       {
66182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66183       };
66184     }
66185   }
66186 }
66187
66188
66189 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
66190   float jresult ;
66191   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66192   float result;
66193
66194   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66195   {
66196     try {
66197       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
66198     } catch (std::out_of_range& e) {
66199       {
66200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66201       };
66202     } catch (std::exception& e) {
66203       {
66204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66205       };
66206     } catch (...) {
66207       {
66208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66209       };
66210     }
66211   }
66212   jresult = result;
66213   return jresult;
66214 }
66215
66216
66217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
66218   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66219   bool arg2 ;
66220
66221   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66222   arg2 = jarg2 ? true : false;
66223   {
66224     try {
66225       (arg1)->SetAnchoring(arg2);
66226     } catch (std::out_of_range& e) {
66227       {
66228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66229       };
66230     } catch (std::exception& e) {
66231       {
66232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66233       };
66234     } catch (...) {
66235       {
66236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66237       };
66238     }
66239   }
66240 }
66241
66242
66243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
66244   unsigned int jresult ;
66245   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66246   bool result;
66247
66248   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66249   {
66250     try {
66251       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
66252     } catch (std::out_of_range& e) {
66253       {
66254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66255       };
66256     } catch (std::exception& e) {
66257       {
66258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66259       };
66260     } catch (...) {
66261       {
66262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66263       };
66264     }
66265   }
66266   jresult = result;
66267   return jresult;
66268 }
66269
66270
66271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
66272   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66273   float arg2 ;
66274
66275   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66276   arg2 = (float)jarg2;
66277   {
66278     try {
66279       (arg1)->SetAnchoringDuration(arg2);
66280     } catch (std::out_of_range& e) {
66281       {
66282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66283       };
66284     } catch (std::exception& e) {
66285       {
66286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66287       };
66288     } catch (...) {
66289       {
66290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66291       };
66292     }
66293   }
66294 }
66295
66296
66297 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
66298   float jresult ;
66299   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66300   float result;
66301
66302   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66303   {
66304     try {
66305       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
66306     } catch (std::out_of_range& e) {
66307       {
66308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66309       };
66310     } catch (std::exception& e) {
66311       {
66312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66313       };
66314     } catch (...) {
66315       {
66316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66317       };
66318     }
66319   }
66320   jresult = result;
66321   return jresult;
66322 }
66323
66324
66325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
66326   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66327   Dali::Toolkit::ItemId arg2 ;
66328   float arg3 ;
66329
66330   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66331   arg2 = (Dali::Toolkit::ItemId)jarg2;
66332   arg3 = (float)jarg3;
66333   {
66334     try {
66335       (arg1)->ScrollToItem(arg2,arg3);
66336     } catch (std::out_of_range& e) {
66337       {
66338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66339       };
66340     } catch (std::exception& e) {
66341       {
66342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66343       };
66344     } catch (...) {
66345       {
66346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66347       };
66348     }
66349   }
66350 }
66351
66352
66353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
66354   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66355   float arg2 ;
66356
66357   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66358   arg2 = (float)jarg2;
66359   {
66360     try {
66361       (arg1)->SetRefreshInterval(arg2);
66362     } catch (std::out_of_range& e) {
66363       {
66364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66365       };
66366     } catch (std::exception& e) {
66367       {
66368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66369       };
66370     } catch (...) {
66371       {
66372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66373       };
66374     }
66375   }
66376 }
66377
66378
66379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
66380   float jresult ;
66381   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66382   float result;
66383
66384   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66385   {
66386     try {
66387       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
66388     } catch (std::out_of_range& e) {
66389       {
66390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66391       };
66392     } catch (std::exception& e) {
66393       {
66394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66395       };
66396     } catch (...) {
66397       {
66398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66399       };
66400     }
66401   }
66402   jresult = result;
66403   return jresult;
66404 }
66405
66406
66407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
66408   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66409
66410   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66411   {
66412     try {
66413       (arg1)->Refresh();
66414     } catch (std::out_of_range& e) {
66415       {
66416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66417       };
66418     } catch (std::exception& e) {
66419       {
66420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66421       };
66422     } catch (...) {
66423       {
66424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66425       };
66426     }
66427   }
66428 }
66429
66430
66431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
66432   void * jresult ;
66433   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66434   Dali::Toolkit::ItemId arg2 ;
66435   Dali::Actor result;
66436
66437   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66438   arg2 = (Dali::Toolkit::ItemId)jarg2;
66439   {
66440     try {
66441       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
66442     } catch (std::out_of_range& e) {
66443       {
66444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66445       };
66446     } catch (std::exception& e) {
66447       {
66448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66449       };
66450     } catch (...) {
66451       {
66452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66453       };
66454     }
66455   }
66456   jresult = new Dali::Actor((const Dali::Actor &)result);
66457   return jresult;
66458 }
66459
66460
66461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
66462   unsigned int jresult ;
66463   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66464   Dali::Actor arg2 ;
66465   Dali::Actor *argp2 ;
66466   Dali::Toolkit::ItemId result;
66467
66468   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66469   argp2 = (Dali::Actor *)jarg2;
66470   if (!argp2) {
66471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66472     return 0;
66473   }
66474   arg2 = *argp2;
66475   {
66476     try {
66477       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
66478     } catch (std::out_of_range& e) {
66479       {
66480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66481       };
66482     } catch (std::exception& e) {
66483       {
66484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66485       };
66486     } catch (...) {
66487       {
66488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66489       };
66490     }
66491   }
66492   jresult = result;
66493   return jresult;
66494 }
66495
66496
66497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
66498   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66499   Dali::Toolkit::Item arg2 ;
66500   float arg3 ;
66501   Dali::Toolkit::Item *argp2 ;
66502
66503   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66504   argp2 = (Dali::Toolkit::Item *)jarg2;
66505   if (!argp2) {
66506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
66507     return ;
66508   }
66509   arg2 = *argp2;
66510   arg3 = (float)jarg3;
66511   {
66512     try {
66513       (arg1)->InsertItem(arg2,arg3);
66514     } catch (std::out_of_range& e) {
66515       {
66516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66517       };
66518     } catch (std::exception& e) {
66519       {
66520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66521       };
66522     } catch (...) {
66523       {
66524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66525       };
66526     }
66527   }
66528 }
66529
66530
66531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
66532   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66533   Dali::Toolkit::ItemContainer *arg2 = 0 ;
66534   float arg3 ;
66535
66536   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66537   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
66538   if (!arg2) {
66539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
66540     return ;
66541   }
66542   arg3 = (float)jarg3;
66543   {
66544     try {
66545       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
66546     } catch (std::out_of_range& e) {
66547       {
66548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66549       };
66550     } catch (std::exception& e) {
66551       {
66552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66553       };
66554     } catch (...) {
66555       {
66556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66557       };
66558     }
66559   }
66560 }
66561
66562
66563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
66564   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66565   Dali::Toolkit::ItemId arg2 ;
66566   float arg3 ;
66567
66568   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66569   arg2 = (Dali::Toolkit::ItemId)jarg2;
66570   arg3 = (float)jarg3;
66571   {
66572     try {
66573       (arg1)->RemoveItem(arg2,arg3);
66574     } catch (std::out_of_range& e) {
66575       {
66576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66577       };
66578     } catch (std::exception& e) {
66579       {
66580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66581       };
66582     } catch (...) {
66583       {
66584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66585       };
66586     }
66587   }
66588 }
66589
66590
66591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
66592   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66593   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
66594   float arg3 ;
66595
66596   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66597   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
66598   if (!arg2) {
66599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
66600     return ;
66601   }
66602   arg3 = (float)jarg3;
66603   {
66604     try {
66605       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
66606     } catch (std::out_of_range& e) {
66607       {
66608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66609       };
66610     } catch (std::exception& e) {
66611       {
66612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66613       };
66614     } catch (...) {
66615       {
66616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66617       };
66618     }
66619   }
66620 }
66621
66622
66623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
66624   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66625   Dali::Toolkit::Item arg2 ;
66626   float arg3 ;
66627   Dali::Toolkit::Item *argp2 ;
66628
66629   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66630   argp2 = (Dali::Toolkit::Item *)jarg2;
66631   if (!argp2) {
66632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
66633     return ;
66634   }
66635   arg2 = *argp2;
66636   arg3 = (float)jarg3;
66637   {
66638     try {
66639       (arg1)->ReplaceItem(arg2,arg3);
66640     } catch (std::out_of_range& e) {
66641       {
66642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66643       };
66644     } catch (std::exception& e) {
66645       {
66646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66647       };
66648     } catch (...) {
66649       {
66650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66651       };
66652     }
66653   }
66654 }
66655
66656
66657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
66658   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66659   Dali::Toolkit::ItemContainer *arg2 = 0 ;
66660   float arg3 ;
66661
66662   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66663   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
66664   if (!arg2) {
66665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
66666     return ;
66667   }
66668   arg3 = (float)jarg3;
66669   {
66670     try {
66671       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
66672     } catch (std::out_of_range& e) {
66673       {
66674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66675       };
66676     } catch (std::exception& e) {
66677       {
66678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66679       };
66680     } catch (...) {
66681       {
66682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66683       };
66684     }
66685   }
66686 }
66687
66688
66689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
66690   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66691   Dali::Vector3 *arg2 = 0 ;
66692
66693   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66694   arg2 = (Dali::Vector3 *)jarg2;
66695   if (!arg2) {
66696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66697     return ;
66698   }
66699   {
66700     try {
66701       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
66702     } catch (std::out_of_range& e) {
66703       {
66704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66705       };
66706     } catch (std::exception& e) {
66707       {
66708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66709       };
66710     } catch (...) {
66711       {
66712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66713       };
66714     }
66715   }
66716 }
66717
66718
66719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
66720   void * jresult ;
66721   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66722   Dali::Vector3 result;
66723
66724   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66725   {
66726     try {
66727       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
66728     } catch (std::out_of_range& e) {
66729       {
66730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66731       };
66732     } catch (std::exception& e) {
66733       {
66734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66735       };
66736     } catch (...) {
66737       {
66738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66739       };
66740     }
66741   }
66742   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
66743   return jresult;
66744 }
66745
66746
66747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
66748   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66749   Dali::Vector3 *arg2 = 0 ;
66750
66751   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66752   arg2 = (Dali::Vector3 *)jarg2;
66753   if (!arg2) {
66754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66755     return ;
66756   }
66757   {
66758     try {
66759       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
66760     } catch (std::out_of_range& e) {
66761       {
66762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66763       };
66764     } catch (std::exception& e) {
66765       {
66766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66767       };
66768     } catch (...) {
66769       {
66770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66771       };
66772     }
66773   }
66774 }
66775
66776
66777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
66778   void * jresult ;
66779   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66780   Dali::Vector3 result;
66781
66782   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66783   {
66784     try {
66785       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
66786     } catch (std::out_of_range& e) {
66787       {
66788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66789       };
66790     } catch (std::exception& e) {
66791       {
66792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66793       };
66794     } catch (...) {
66795       {
66796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66797       };
66798     }
66799   }
66800   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
66801   return jresult;
66802 }
66803
66804
66805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
66806   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66807   Dali::Toolkit::ItemRange *arg2 = 0 ;
66808
66809   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66810   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
66811   if (!arg2) {
66812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
66813     return ;
66814   }
66815   {
66816     try {
66817       (arg1)->GetItemsRange(*arg2);
66818     } catch (std::out_of_range& e) {
66819       {
66820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66821       };
66822     } catch (std::exception& e) {
66823       {
66824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66825       };
66826     } catch (...) {
66827       {
66828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66829       };
66830     }
66831   }
66832 }
66833
66834
66835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
66836   void * jresult ;
66837   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66838   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
66839
66840   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66841   {
66842     try {
66843       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
66844     } catch (std::out_of_range& e) {
66845       {
66846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66847       };
66848     } catch (std::exception& e) {
66849       {
66850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66851       };
66852     } catch (...) {
66853       {
66854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66855       };
66856     }
66857   }
66858   jresult = (void *)result;
66859   return jresult;
66860 }
66861
66862
66863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
66864   Dali::Vector3 *arg1 = 0 ;
66865   PropertyInputContainer *arg2 = 0 ;
66866
66867   arg1 = (Dali::Vector3 *)jarg1;
66868   if (!arg1) {
66869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
66870     return ;
66871   }
66872   arg2 = (PropertyInputContainer *)jarg2;
66873   if (!arg2) {
66874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
66875     return ;
66876   }
66877   {
66878     try {
66879       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
66880     } catch (std::out_of_range& e) {
66881       {
66882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66883       };
66884     } catch (std::exception& e) {
66885       {
66886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66887       };
66888     } catch (...) {
66889       {
66890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66891       };
66892     }
66893   }
66894 }
66895
66896
66897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
66898   Dali::Vector3 *arg1 = 0 ;
66899   PropertyInputContainer *arg2 = 0 ;
66900
66901   arg1 = (Dali::Vector3 *)jarg1;
66902   if (!arg1) {
66903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
66904     return ;
66905   }
66906   arg2 = (PropertyInputContainer *)jarg2;
66907   if (!arg2) {
66908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
66909     return ;
66910   }
66911   {
66912     try {
66913       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
66914     } catch (std::out_of_range& e) {
66915       {
66916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66917       };
66918     } catch (std::exception& e) {
66919       {
66920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66921       };
66922     } catch (...) {
66923       {
66924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66925       };
66926     }
66927   }
66928 }
66929
66930
66931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
66932   void * jresult ;
66933   Dali::Toolkit::ScrollViewEffect *result = 0 ;
66934
66935   {
66936     try {
66937       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
66938     } catch (std::out_of_range& e) {
66939       {
66940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66941       };
66942     } catch (std::exception& e) {
66943       {
66944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66945       };
66946     } catch (...) {
66947       {
66948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66949       };
66950     }
66951   }
66952   jresult = (void *)result;
66953   return jresult;
66954 }
66955
66956
66957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
66958   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
66959
66960   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
66961   {
66962     try {
66963       delete arg1;
66964     } catch (std::out_of_range& e) {
66965       {
66966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66967       };
66968     } catch (std::exception& e) {
66969       {
66970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66971       };
66972     } catch (...) {
66973       {
66974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66975       };
66976     }
66977   }
66978 }
66979
66980
66981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
66982   void * jresult ;
66983   Dali::Path arg1 ;
66984   Dali::Vector3 *arg2 = 0 ;
66985   Dali::Property::Index arg3 ;
66986   Dali::Vector3 *arg4 = 0 ;
66987   unsigned int arg5 ;
66988   Dali::Path *argp1 ;
66989   Dali::Toolkit::ScrollViewPagePathEffect result;
66990
66991   argp1 = (Dali::Path *)jarg1;
66992   if (!argp1) {
66993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
66994     return 0;
66995   }
66996   arg1 = *argp1;
66997   arg2 = (Dali::Vector3 *)jarg2;
66998   if (!arg2) {
66999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67000     return 0;
67001   }
67002   arg3 = (Dali::Property::Index)jarg3;
67003   arg4 = (Dali::Vector3 *)jarg4;
67004   if (!arg4) {
67005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67006     return 0;
67007   }
67008   arg5 = (unsigned int)jarg5;
67009   {
67010     try {
67011       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
67012     } catch (std::out_of_range& e) {
67013       {
67014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67015       };
67016     } catch (std::exception& e) {
67017       {
67018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67019       };
67020     } catch (...) {
67021       {
67022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67023       };
67024     }
67025   }
67026   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
67027   return jresult;
67028 }
67029
67030
67031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
67032   void * jresult ;
67033   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
67034
67035   {
67036     try {
67037       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
67038     } catch (std::out_of_range& e) {
67039       {
67040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67041       };
67042     } catch (std::exception& e) {
67043       {
67044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67045       };
67046     } catch (...) {
67047       {
67048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67049       };
67050     }
67051   }
67052   jresult = (void *)result;
67053   return jresult;
67054 }
67055
67056
67057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
67058   void * jresult ;
67059   Dali::BaseHandle arg1 ;
67060   Dali::BaseHandle *argp1 ;
67061   Dali::Toolkit::ScrollViewPagePathEffect result;
67062
67063   argp1 = (Dali::BaseHandle *)jarg1;
67064   if (!argp1) {
67065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67066     return 0;
67067   }
67068   arg1 = *argp1;
67069   {
67070     try {
67071       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
67072     } catch (std::out_of_range& e) {
67073       {
67074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67075       };
67076     } catch (std::exception& e) {
67077       {
67078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67079       };
67080     } catch (...) {
67081       {
67082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67083       };
67084     }
67085   }
67086   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
67087   return jresult;
67088 }
67089
67090
67091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
67092   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
67093   Dali::Actor arg2 ;
67094   unsigned int arg3 ;
67095   Dali::Actor *argp2 ;
67096
67097   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
67098   argp2 = (Dali::Actor *)jarg2;
67099   if (!argp2) {
67100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67101     return ;
67102   }
67103   arg2 = *argp2;
67104   arg3 = (unsigned int)jarg3;
67105   {
67106     try {
67107       (arg1)->ApplyToPage(arg2,arg3);
67108     } catch (std::out_of_range& e) {
67109       {
67110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67111       };
67112     } catch (std::exception& e) {
67113       {
67114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67115       };
67116     } catch (...) {
67117       {
67118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67119       };
67120     }
67121   }
67122 }
67123
67124
67125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
67126   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
67127
67128   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
67129   {
67130     try {
67131       delete arg1;
67132     } catch (std::out_of_range& e) {
67133       {
67134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67135       };
67136     } catch (std::exception& e) {
67137       {
67138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67139       };
67140     } catch (...) {
67141       {
67142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67143       };
67144     }
67145   }
67146 }
67147
67148
67149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
67150   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67151   Dali::Toolkit::ClampState arg2 ;
67152
67153   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67154   arg2 = (Dali::Toolkit::ClampState)jarg2;
67155   if (arg1) (arg1)->x = arg2;
67156 }
67157
67158
67159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
67160   int jresult ;
67161   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67162   Dali::Toolkit::ClampState result;
67163
67164   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67165   result = (Dali::Toolkit::ClampState) ((arg1)->x);
67166   jresult = (int)result;
67167   return jresult;
67168 }
67169
67170
67171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
67172   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67173   Dali::Toolkit::ClampState arg2 ;
67174
67175   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67176   arg2 = (Dali::Toolkit::ClampState)jarg2;
67177   if (arg1) (arg1)->y = arg2;
67178 }
67179
67180
67181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
67182   int jresult ;
67183   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67184   Dali::Toolkit::ClampState result;
67185
67186   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67187   result = (Dali::Toolkit::ClampState) ((arg1)->y);
67188   jresult = (int)result;
67189   return jresult;
67190 }
67191
67192
67193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
67194   void * jresult ;
67195   Dali::Toolkit::ClampState2D *result = 0 ;
67196
67197   {
67198     try {
67199       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
67200     } catch (std::out_of_range& e) {
67201       {
67202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67203       };
67204     } catch (std::exception& e) {
67205       {
67206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67207       };
67208     } catch (...) {
67209       {
67210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67211       };
67212     }
67213   }
67214   jresult = (void *)result;
67215   return jresult;
67216 }
67217
67218
67219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
67220   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67221
67222   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67223   {
67224     try {
67225       delete arg1;
67226     } catch (std::out_of_range& e) {
67227       {
67228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67229       };
67230     } catch (std::exception& e) {
67231       {
67232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67233       };
67234     } catch (...) {
67235       {
67236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67237       };
67238     }
67239   }
67240 }
67241
67242
67243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
67244   void * jresult ;
67245   float arg1 ;
67246   float arg2 ;
67247   bool arg3 ;
67248   Dali::Toolkit::RulerDomain *result = 0 ;
67249
67250   arg1 = (float)jarg1;
67251   arg2 = (float)jarg2;
67252   arg3 = jarg3 ? true : false;
67253   {
67254     try {
67255       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
67256     } catch (std::out_of_range& e) {
67257       {
67258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67259       };
67260     } catch (std::exception& e) {
67261       {
67262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67263       };
67264     } catch (...) {
67265       {
67266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67267       };
67268     }
67269   }
67270   jresult = (void *)result;
67271   return jresult;
67272 }
67273
67274
67275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
67276   void * jresult ;
67277   float arg1 ;
67278   float arg2 ;
67279   Dali::Toolkit::RulerDomain *result = 0 ;
67280
67281   arg1 = (float)jarg1;
67282   arg2 = (float)jarg2;
67283   {
67284     try {
67285       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
67286     } catch (std::out_of_range& e) {
67287       {
67288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67289       };
67290     } catch (std::exception& e) {
67291       {
67292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67293       };
67294     } catch (...) {
67295       {
67296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67297       };
67298     }
67299   }
67300   jresult = (void *)result;
67301   return jresult;
67302 }
67303
67304
67305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
67306   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67307   float arg2 ;
67308
67309   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67310   arg2 = (float)jarg2;
67311   if (arg1) (arg1)->min = arg2;
67312 }
67313
67314
67315 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
67316   float jresult ;
67317   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67318   float result;
67319
67320   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67321   result = (float) ((arg1)->min);
67322   jresult = result;
67323   return jresult;
67324 }
67325
67326
67327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
67328   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67329   float arg2 ;
67330
67331   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67332   arg2 = (float)jarg2;
67333   if (arg1) (arg1)->max = arg2;
67334 }
67335
67336
67337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
67338   float jresult ;
67339   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67340   float result;
67341
67342   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67343   result = (float) ((arg1)->max);
67344   jresult = result;
67345   return jresult;
67346 }
67347
67348
67349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
67350   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67351   bool arg2 ;
67352
67353   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67354   arg2 = jarg2 ? true : false;
67355   if (arg1) (arg1)->enabled = arg2;
67356 }
67357
67358
67359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
67360   unsigned int jresult ;
67361   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67362   bool result;
67363
67364   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67365   result = (bool) ((arg1)->enabled);
67366   jresult = result;
67367   return jresult;
67368 }
67369
67370
67371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
67372   float jresult ;
67373   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67374   float arg2 ;
67375   float arg3 ;
67376   float arg4 ;
67377   float result;
67378
67379   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67380   arg2 = (float)jarg2;
67381   arg3 = (float)jarg3;
67382   arg4 = (float)jarg4;
67383   {
67384     try {
67385       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
67386     } catch (std::out_of_range& e) {
67387       {
67388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67389       };
67390     } catch (std::exception& e) {
67391       {
67392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67393       };
67394     } catch (...) {
67395       {
67396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67397       };
67398     }
67399   }
67400   jresult = result;
67401   return jresult;
67402 }
67403
67404
67405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
67406   float jresult ;
67407   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67408   float arg2 ;
67409   float arg3 ;
67410   float result;
67411
67412   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67413   arg2 = (float)jarg2;
67414   arg3 = (float)jarg3;
67415   {
67416     try {
67417       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
67418     } catch (std::out_of_range& e) {
67419       {
67420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67421       };
67422     } catch (std::exception& e) {
67423       {
67424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67425       };
67426     } catch (...) {
67427       {
67428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67429       };
67430     }
67431   }
67432   jresult = result;
67433   return jresult;
67434 }
67435
67436
67437 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
67438   float jresult ;
67439   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67440   float arg2 ;
67441   float result;
67442
67443   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67444   arg2 = (float)jarg2;
67445   {
67446     try {
67447       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
67448     } catch (std::out_of_range& e) {
67449       {
67450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67451       };
67452     } catch (std::exception& e) {
67453       {
67454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67455       };
67456     } catch (...) {
67457       {
67458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67459       };
67460     }
67461   }
67462   jresult = result;
67463   return jresult;
67464 }
67465
67466
67467 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
67468   float jresult ;
67469   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67470   float arg2 ;
67471   float arg3 ;
67472   float arg4 ;
67473   Dali::Toolkit::ClampState *arg5 = 0 ;
67474   float result;
67475
67476   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67477   arg2 = (float)jarg2;
67478   arg3 = (float)jarg3;
67479   arg4 = (float)jarg4;
67480   arg5 = (Dali::Toolkit::ClampState *)jarg5;
67481   if (!arg5) {
67482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
67483     return 0;
67484   }
67485   {
67486     try {
67487       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
67488     } catch (std::out_of_range& e) {
67489       {
67490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67491       };
67492     } catch (std::exception& e) {
67493       {
67494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67495       };
67496     } catch (...) {
67497       {
67498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67499       };
67500     }
67501   }
67502   jresult = result;
67503   return jresult;
67504 }
67505
67506
67507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
67508   float jresult ;
67509   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67510   float result;
67511
67512   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67513   {
67514     try {
67515       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
67516     } catch (std::out_of_range& e) {
67517       {
67518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67519       };
67520     } catch (std::exception& e) {
67521       {
67522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67523       };
67524     } catch (...) {
67525       {
67526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67527       };
67528     }
67529   }
67530   jresult = result;
67531   return jresult;
67532 }
67533
67534
67535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
67536   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67537
67538   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67539   {
67540     try {
67541       delete arg1;
67542     } catch (std::out_of_range& e) {
67543       {
67544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67545       };
67546     } catch (std::exception& e) {
67547       {
67548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67549       };
67550     } catch (...) {
67551       {
67552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67553       };
67554     }
67555   }
67556 }
67557
67558
67559 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
67560   float jresult ;
67561   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67562   float arg2 ;
67563   float arg3 ;
67564   float result;
67565
67566   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67567   arg2 = (float)jarg2;
67568   arg3 = (float)jarg3;
67569   {
67570     try {
67571       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
67572     } catch (std::out_of_range& e) {
67573       {
67574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67575       };
67576     } catch (std::exception& e) {
67577       {
67578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67579       };
67580     } catch (...) {
67581       {
67582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67583       };
67584     }
67585   }
67586   jresult = result;
67587   return jresult;
67588 }
67589
67590
67591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
67592   float jresult ;
67593   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67594   float arg2 ;
67595   float result;
67596
67597   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67598   arg2 = (float)jarg2;
67599   {
67600     try {
67601       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
67602     } catch (std::out_of_range& e) {
67603       {
67604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67605       };
67606     } catch (std::exception& e) {
67607       {
67608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67609       };
67610     } catch (...) {
67611       {
67612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67613       };
67614     }
67615   }
67616   jresult = result;
67617   return jresult;
67618 }
67619
67620
67621 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
67622   float jresult ;
67623   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67624   unsigned int arg2 ;
67625   unsigned int *arg3 = 0 ;
67626   bool arg4 ;
67627   float result;
67628
67629   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67630   arg2 = (unsigned int)jarg2;
67631   arg3 = (unsigned int *)jarg3;
67632   arg4 = jarg4 ? true : false;
67633   {
67634     try {
67635       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
67636     } catch (std::out_of_range& e) {
67637       {
67638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67639       };
67640     } catch (std::exception& e) {
67641       {
67642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67643       };
67644     } catch (...) {
67645       {
67646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67647       };
67648     }
67649   }
67650   jresult = result;
67651   return jresult;
67652 }
67653
67654
67655 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
67656   unsigned int jresult ;
67657   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67658   float arg2 ;
67659   bool arg3 ;
67660   unsigned int result;
67661
67662   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67663   arg2 = (float)jarg2;
67664   arg3 = jarg3 ? true : false;
67665   {
67666     try {
67667       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
67668     } catch (std::out_of_range& e) {
67669       {
67670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67671       };
67672     } catch (std::exception& e) {
67673       {
67674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67675       };
67676     } catch (...) {
67677       {
67678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67679       };
67680     }
67681   }
67682   jresult = result;
67683   return jresult;
67684 }
67685
67686
67687 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
67688   unsigned int jresult ;
67689   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67690   unsigned int result;
67691
67692   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67693   {
67694     try {
67695       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
67696     } catch (std::out_of_range& e) {
67697       {
67698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67699       };
67700     } catch (std::exception& e) {
67701       {
67702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67703       };
67704     } catch (...) {
67705       {
67706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67707       };
67708     }
67709   }
67710   jresult = result;
67711   return jresult;
67712 }
67713
67714
67715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
67716   int jresult ;
67717   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67718   Dali::Toolkit::Ruler::RulerType result;
67719
67720   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67721   {
67722     try {
67723       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
67724     } catch (std::out_of_range& e) {
67725       {
67726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67727       };
67728     } catch (std::exception& e) {
67729       {
67730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67731       };
67732     } catch (...) {
67733       {
67734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67735       };
67736     }
67737   }
67738   jresult = (int)result;
67739   return jresult;
67740 }
67741
67742
67743 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
67744   unsigned int jresult ;
67745   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67746   bool result;
67747
67748   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67749   {
67750     try {
67751       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
67752     } catch (std::out_of_range& e) {
67753       {
67754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67755       };
67756     } catch (std::exception& e) {
67757       {
67758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67759       };
67760     } catch (...) {
67761       {
67762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67763       };
67764     }
67765   }
67766   jresult = result;
67767   return jresult;
67768 }
67769
67770
67771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
67772   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67773
67774   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67775   {
67776     try {
67777       (arg1)->Enable();
67778     } catch (std::out_of_range& e) {
67779       {
67780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67781       };
67782     } catch (std::exception& e) {
67783       {
67784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67785       };
67786     } catch (...) {
67787       {
67788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67789       };
67790     }
67791   }
67792 }
67793
67794
67795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
67796   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67797
67798   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67799   {
67800     try {
67801       (arg1)->Disable();
67802     } catch (std::out_of_range& e) {
67803       {
67804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67805       };
67806     } catch (std::exception& e) {
67807       {
67808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67809       };
67810     } catch (...) {
67811       {
67812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67813       };
67814     }
67815   }
67816 }
67817
67818
67819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
67820   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67821   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
67822   Dali::Toolkit::RulerDomain *argp2 ;
67823
67824   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67825   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
67826   if (!argp2) {
67827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
67828     return ;
67829   }
67830   arg2 = *argp2;
67831   {
67832     try {
67833       (arg1)->SetDomain(arg2);
67834     } catch (std::out_of_range& e) {
67835       {
67836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67837       };
67838     } catch (std::exception& e) {
67839       {
67840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67841       };
67842     } catch (...) {
67843       {
67844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67845       };
67846     }
67847   }
67848 }
67849
67850
67851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
67852   void * jresult ;
67853   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67854   Dali::Toolkit::RulerDomain *result = 0 ;
67855
67856   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67857   {
67858     try {
67859       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
67860     } catch (std::out_of_range& e) {
67861       {
67862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67863       };
67864     } catch (std::exception& e) {
67865       {
67866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67867       };
67868     } catch (...) {
67869       {
67870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67871       };
67872     }
67873   }
67874   jresult = (void *)result;
67875   return jresult;
67876 }
67877
67878
67879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
67880   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67881
67882   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67883   {
67884     try {
67885       (arg1)->DisableDomain();
67886     } catch (std::out_of_range& e) {
67887       {
67888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67889       };
67890     } catch (std::exception& e) {
67891       {
67892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67893       };
67894     } catch (...) {
67895       {
67896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67897       };
67898     }
67899   }
67900 }
67901
67902
67903 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
67904   float jresult ;
67905   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67906   float arg2 ;
67907   float arg3 ;
67908   float arg4 ;
67909   float result;
67910
67911   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67912   arg2 = (float)jarg2;
67913   arg3 = (float)jarg3;
67914   arg4 = (float)jarg4;
67915   {
67916     try {
67917       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
67918     } catch (std::out_of_range& e) {
67919       {
67920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67921       };
67922     } catch (std::exception& e) {
67923       {
67924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67925       };
67926     } catch (...) {
67927       {
67928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67929       };
67930     }
67931   }
67932   jresult = result;
67933   return jresult;
67934 }
67935
67936
67937 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
67938   float jresult ;
67939   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67940   float arg2 ;
67941   float arg3 ;
67942   float result;
67943
67944   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67945   arg2 = (float)jarg2;
67946   arg3 = (float)jarg3;
67947   {
67948     try {
67949       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
67950     } catch (std::out_of_range& e) {
67951       {
67952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67953       };
67954     } catch (std::exception& e) {
67955       {
67956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67957       };
67958     } catch (...) {
67959       {
67960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67961       };
67962     }
67963   }
67964   jresult = result;
67965   return jresult;
67966 }
67967
67968
67969 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
67970   float jresult ;
67971   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67972   float arg2 ;
67973   float result;
67974
67975   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67976   arg2 = (float)jarg2;
67977   {
67978     try {
67979       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
67980     } catch (std::out_of_range& e) {
67981       {
67982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67983       };
67984     } catch (std::exception& e) {
67985       {
67986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67987       };
67988     } catch (...) {
67989       {
67990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67991       };
67992     }
67993   }
67994   jresult = result;
67995   return jresult;
67996 }
67997
67998
67999 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
68000   float jresult ;
68001   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68002   float arg2 ;
68003   float arg3 ;
68004   float arg4 ;
68005   Dali::Toolkit::ClampState *arg5 = 0 ;
68006   float result;
68007
68008   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68009   arg2 = (float)jarg2;
68010   arg3 = (float)jarg3;
68011   arg4 = (float)jarg4;
68012   arg5 = (Dali::Toolkit::ClampState *)jarg5;
68013   if (!arg5) {
68014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
68015     return 0;
68016   }
68017   {
68018     try {
68019       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
68020     } catch (std::out_of_range& e) {
68021       {
68022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68023       };
68024     } catch (std::exception& e) {
68025       {
68026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68027       };
68028     } catch (...) {
68029       {
68030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68031       };
68032     }
68033   }
68034   jresult = result;
68035   return jresult;
68036 }
68037
68038
68039 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
68040   float jresult ;
68041   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68042   float arg2 ;
68043   float arg3 ;
68044   float arg4 ;
68045   float arg5 ;
68046   float result;
68047
68048   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68049   arg2 = (float)jarg2;
68050   arg3 = (float)jarg3;
68051   arg4 = (float)jarg4;
68052   arg5 = (float)jarg5;
68053   {
68054     try {
68055       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
68056     } catch (std::out_of_range& e) {
68057       {
68058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68059       };
68060     } catch (std::exception& e) {
68061       {
68062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68063       };
68064     } catch (...) {
68065       {
68066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68067       };
68068     }
68069   }
68070   jresult = result;
68071   return jresult;
68072 }
68073
68074
68075 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
68076   float jresult ;
68077   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68078   float arg2 ;
68079   float arg3 ;
68080   float arg4 ;
68081   float result;
68082
68083   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68084   arg2 = (float)jarg2;
68085   arg3 = (float)jarg3;
68086   arg4 = (float)jarg4;
68087   {
68088     try {
68089       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
68090     } catch (std::out_of_range& e) {
68091       {
68092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68093       };
68094     } catch (std::exception& e) {
68095       {
68096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68097       };
68098     } catch (...) {
68099       {
68100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68101       };
68102     }
68103   }
68104   jresult = result;
68105   return jresult;
68106 }
68107
68108
68109 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
68110   float jresult ;
68111   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68112   float arg2 ;
68113   float arg3 ;
68114   float result;
68115
68116   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68117   arg2 = (float)jarg2;
68118   arg3 = (float)jarg3;
68119   {
68120     try {
68121       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
68122     } catch (std::out_of_range& e) {
68123       {
68124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68125       };
68126     } catch (std::exception& e) {
68127       {
68128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68129       };
68130     } catch (...) {
68131       {
68132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68133       };
68134     }
68135   }
68136   jresult = result;
68137   return jresult;
68138 }
68139
68140
68141 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
68142   float jresult ;
68143   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68144   float arg2 ;
68145   float result;
68146
68147   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68148   arg2 = (float)jarg2;
68149   {
68150     try {
68151       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
68152     } catch (std::out_of_range& e) {
68153       {
68154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68155       };
68156     } catch (std::exception& e) {
68157       {
68158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68159       };
68160     } catch (...) {
68161       {
68162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68163       };
68164     }
68165   }
68166   jresult = result;
68167   return jresult;
68168 }
68169
68170
68171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
68172   float jresult ;
68173   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68174   float arg2 ;
68175   float arg3 ;
68176   float arg4 ;
68177   float arg5 ;
68178   Dali::Toolkit::ClampState *arg6 = 0 ;
68179   float result;
68180
68181   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68182   arg2 = (float)jarg2;
68183   arg3 = (float)jarg3;
68184   arg4 = (float)jarg4;
68185   arg5 = (float)jarg5;
68186   arg6 = (Dali::Toolkit::ClampState *)jarg6;
68187   if (!arg6) {
68188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
68189     return 0;
68190   }
68191   {
68192     try {
68193       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
68194     } catch (std::out_of_range& e) {
68195       {
68196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68197       };
68198     } catch (std::exception& e) {
68199       {
68200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68201       };
68202     } catch (...) {
68203       {
68204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68205       };
68206     }
68207   }
68208   jresult = result;
68209   return jresult;
68210 }
68211
68212
68213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
68214   void * jresult ;
68215   Dali::Toolkit::DefaultRuler *result = 0 ;
68216
68217   {
68218     try {
68219       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
68220     } catch (std::out_of_range& e) {
68221       {
68222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68223       };
68224     } catch (std::exception& e) {
68225       {
68226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68227       };
68228     } catch (...) {
68229       {
68230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68231       };
68232     }
68233   }
68234   jresult = (void *)result;
68235   return jresult;
68236 }
68237
68238
68239 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
68240   float jresult ;
68241   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68242   float arg2 ;
68243   float arg3 ;
68244   float result;
68245
68246   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68247   arg2 = (float)jarg2;
68248   arg3 = (float)jarg3;
68249   {
68250     try {
68251       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
68252     } catch (std::out_of_range& e) {
68253       {
68254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68255       };
68256     } catch (std::exception& e) {
68257       {
68258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68259       };
68260     } catch (...) {
68261       {
68262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68263       };
68264     }
68265   }
68266   jresult = result;
68267   return jresult;
68268 }
68269
68270
68271 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
68272   float jresult ;
68273   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68274   unsigned int arg2 ;
68275   unsigned int *arg3 = 0 ;
68276   bool arg4 ;
68277   float result;
68278
68279   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68280   arg2 = (unsigned int)jarg2;
68281   arg3 = (unsigned int *)jarg3;
68282   arg4 = jarg4 ? true : false;
68283   {
68284     try {
68285       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
68286     } catch (std::out_of_range& e) {
68287       {
68288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68289       };
68290     } catch (std::exception& e) {
68291       {
68292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68293       };
68294     } catch (...) {
68295       {
68296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68297       };
68298     }
68299   }
68300   jresult = result;
68301   return jresult;
68302 }
68303
68304
68305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
68306   unsigned int jresult ;
68307   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68308   float arg2 ;
68309   bool arg3 ;
68310   unsigned int result;
68311
68312   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68313   arg2 = (float)jarg2;
68314   arg3 = jarg3 ? true : false;
68315   {
68316     try {
68317       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
68318     } catch (std::out_of_range& e) {
68319       {
68320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68321       };
68322     } catch (std::exception& e) {
68323       {
68324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68325       };
68326     } catch (...) {
68327       {
68328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68329       };
68330     }
68331   }
68332   jresult = result;
68333   return jresult;
68334 }
68335
68336
68337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
68338   unsigned int jresult ;
68339   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68340   unsigned int result;
68341
68342   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68343   {
68344     try {
68345       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
68346     } catch (std::out_of_range& e) {
68347       {
68348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68349       };
68350     } catch (std::exception& e) {
68351       {
68352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68353       };
68354     } catch (...) {
68355       {
68356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68357       };
68358     }
68359   }
68360   jresult = result;
68361   return jresult;
68362 }
68363
68364
68365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
68366   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68367
68368   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68369   {
68370     try {
68371       delete arg1;
68372     } catch (std::out_of_range& e) {
68373       {
68374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68375       };
68376     } catch (std::exception& e) {
68377       {
68378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68379       };
68380     } catch (...) {
68381       {
68382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68383       };
68384     }
68385   }
68386 }
68387
68388
68389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
68390   void * jresult ;
68391   float arg1 ;
68392   Dali::Toolkit::FixedRuler *result = 0 ;
68393
68394   arg1 = (float)jarg1;
68395   {
68396     try {
68397       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
68398     } catch (std::out_of_range& e) {
68399       {
68400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68401       };
68402     } catch (std::exception& e) {
68403       {
68404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68405       };
68406     } catch (...) {
68407       {
68408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68409       };
68410     }
68411   }
68412   jresult = (void *)result;
68413   return jresult;
68414 }
68415
68416
68417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
68418   void * jresult ;
68419   Dali::Toolkit::FixedRuler *result = 0 ;
68420
68421   {
68422     try {
68423       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
68424     } catch (std::out_of_range& e) {
68425       {
68426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68427       };
68428     } catch (std::exception& e) {
68429       {
68430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68431       };
68432     } catch (...) {
68433       {
68434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68435       };
68436     }
68437   }
68438   jresult = (void *)result;
68439   return jresult;
68440 }
68441
68442
68443 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
68444   float jresult ;
68445   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68446   float arg2 ;
68447   float arg3 ;
68448   float result;
68449
68450   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68451   arg2 = (float)jarg2;
68452   arg3 = (float)jarg3;
68453   {
68454     try {
68455       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
68456     } catch (std::out_of_range& e) {
68457       {
68458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68459       };
68460     } catch (std::exception& e) {
68461       {
68462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68463       };
68464     } catch (...) {
68465       {
68466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68467       };
68468     }
68469   }
68470   jresult = result;
68471   return jresult;
68472 }
68473
68474
68475 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
68476   float jresult ;
68477   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68478   unsigned int arg2 ;
68479   unsigned int *arg3 = 0 ;
68480   bool arg4 ;
68481   float result;
68482
68483   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68484   arg2 = (unsigned int)jarg2;
68485   arg3 = (unsigned int *)jarg3;
68486   arg4 = jarg4 ? true : false;
68487   {
68488     try {
68489       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
68490     } catch (std::out_of_range& e) {
68491       {
68492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68493       };
68494     } catch (std::exception& e) {
68495       {
68496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68497       };
68498     } catch (...) {
68499       {
68500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68501       };
68502     }
68503   }
68504   jresult = result;
68505   return jresult;
68506 }
68507
68508
68509 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
68510   unsigned int jresult ;
68511   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68512   float arg2 ;
68513   bool arg3 ;
68514   unsigned int result;
68515
68516   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68517   arg2 = (float)jarg2;
68518   arg3 = jarg3 ? true : false;
68519   {
68520     try {
68521       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
68522     } catch (std::out_of_range& e) {
68523       {
68524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68525       };
68526     } catch (std::exception& e) {
68527       {
68528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68529       };
68530     } catch (...) {
68531       {
68532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68533       };
68534     }
68535   }
68536   jresult = result;
68537   return jresult;
68538 }
68539
68540
68541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
68542   unsigned int jresult ;
68543   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68544   unsigned int result;
68545
68546   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68547   {
68548     try {
68549       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
68550     } catch (std::out_of_range& e) {
68551       {
68552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68553       };
68554     } catch (std::exception& e) {
68555       {
68556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68557       };
68558     } catch (...) {
68559       {
68560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68561       };
68562     }
68563   }
68564   jresult = result;
68565   return jresult;
68566 }
68567
68568
68569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
68570   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68571
68572   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68573   {
68574     try {
68575       delete arg1;
68576     } catch (std::out_of_range& e) {
68577       {
68578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68579       };
68580     } catch (std::exception& e) {
68581       {
68582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68583       };
68584     } catch (...) {
68585       {
68586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68587       };
68588     }
68589   }
68590 }
68591
68592
68593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
68594   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68595   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
68596
68597   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68598   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
68599   if (arg1) (arg1)->scale = *arg2;
68600 }
68601
68602
68603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
68604   void * jresult ;
68605   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68606   Dali::Toolkit::ClampState2D *result = 0 ;
68607
68608   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68609   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
68610   jresult = (void *)result;
68611   return jresult;
68612 }
68613
68614
68615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
68616   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68617   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
68618
68619   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68620   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
68621   if (arg1) (arg1)->position = *arg2;
68622 }
68623
68624
68625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
68626   void * jresult ;
68627   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68628   Dali::Toolkit::ClampState2D *result = 0 ;
68629
68630   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68631   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
68632   jresult = (void *)result;
68633   return jresult;
68634 }
68635
68636
68637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
68638   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68639   Dali::Toolkit::ClampState arg2 ;
68640
68641   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68642   arg2 = (Dali::Toolkit::ClampState)jarg2;
68643   if (arg1) (arg1)->rotation = arg2;
68644 }
68645
68646
68647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
68648   int jresult ;
68649   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68650   Dali::Toolkit::ClampState result;
68651
68652   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68653   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
68654   jresult = (int)result;
68655   return jresult;
68656 }
68657
68658
68659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
68660   void * jresult ;
68661   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
68662
68663   {
68664     try {
68665       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
68666     } catch (std::out_of_range& e) {
68667       {
68668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68669       };
68670     } catch (std::exception& e) {
68671       {
68672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68673       };
68674     } catch (...) {
68675       {
68676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68677       };
68678     }
68679   }
68680   jresult = (void *)result;
68681   return jresult;
68682 }
68683
68684
68685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
68686   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68687
68688   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68689   {
68690     try {
68691       delete arg1;
68692     } catch (std::out_of_range& e) {
68693       {
68694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68695       };
68696     } catch (std::exception& e) {
68697       {
68698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68699       };
68700     } catch (...) {
68701       {
68702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68703       };
68704     }
68705   }
68706 }
68707
68708
68709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
68710   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68711   Dali::Toolkit::SnapType arg2 ;
68712
68713   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68714   arg2 = (Dali::Toolkit::SnapType)jarg2;
68715   if (arg1) (arg1)->type = arg2;
68716 }
68717
68718
68719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
68720   int jresult ;
68721   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68722   Dali::Toolkit::SnapType result;
68723
68724   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68725   result = (Dali::Toolkit::SnapType) ((arg1)->type);
68726   jresult = (int)result;
68727   return jresult;
68728 }
68729
68730
68731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
68732   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68733   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
68734
68735   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68736   arg2 = (Dali::Vector2 *)jarg2;
68737   if (arg1) (arg1)->position = *arg2;
68738 }
68739
68740
68741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
68742   void * jresult ;
68743   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68744   Dali::Vector2 *result = 0 ;
68745
68746   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68747   result = (Dali::Vector2 *)& ((arg1)->position);
68748   jresult = (void *)result;
68749   return jresult;
68750 }
68751
68752
68753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
68754   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68755   float arg2 ;
68756
68757   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68758   arg2 = (float)jarg2;
68759   if (arg1) (arg1)->duration = arg2;
68760 }
68761
68762
68763 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
68764   float jresult ;
68765   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68766   float result;
68767
68768   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68769   result = (float) ((arg1)->duration);
68770   jresult = result;
68771   return jresult;
68772 }
68773
68774
68775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
68776   void * jresult ;
68777   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
68778
68779   {
68780     try {
68781       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
68782     } catch (std::out_of_range& e) {
68783       {
68784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68785       };
68786     } catch (std::exception& e) {
68787       {
68788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68789       };
68790     } catch (...) {
68791       {
68792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68793       };
68794     }
68795   }
68796   jresult = (void *)result;
68797   return jresult;
68798 }
68799
68800
68801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
68802   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68803
68804   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68805   {
68806     try {
68807       delete arg1;
68808     } catch (std::out_of_range& e) {
68809       {
68810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68811       };
68812     } catch (std::exception& e) {
68813       {
68814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68815       };
68816     } catch (...) {
68817       {
68818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68819       };
68820     }
68821   }
68822 }
68823
68824
68825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
68826   int jresult ;
68827   int result;
68828
68829   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
68830   jresult = (int)result;
68831   return jresult;
68832 }
68833
68834
68835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
68836   int jresult ;
68837   int result;
68838
68839   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
68840   jresult = (int)result;
68841   return jresult;
68842 }
68843
68844
68845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
68846   int jresult ;
68847   int result;
68848
68849   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
68850   jresult = (int)result;
68851   return jresult;
68852 }
68853
68854
68855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
68856   int jresult ;
68857   int result;
68858
68859   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
68860   jresult = (int)result;
68861   return jresult;
68862 }
68863
68864
68865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
68866   int jresult ;
68867   int result;
68868
68869   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
68870   jresult = (int)result;
68871   return jresult;
68872 }
68873
68874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
68875   int jresult ;
68876   int result;
68877
68878   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
68879   jresult = (int)result;
68880   return jresult;
68881 }
68882
68883
68884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
68885   int jresult ;
68886   int result;
68887
68888   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
68889   jresult = (int)result;
68890   return jresult;
68891 }
68892
68893
68894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
68895   int jresult ;
68896   int result;
68897
68898   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
68899   jresult = (int)result;
68900   return jresult;
68901 }
68902
68903
68904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
68905   int jresult ;
68906   int result;
68907
68908   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
68909   jresult = (int)result;
68910   return jresult;
68911 }
68912
68913
68914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
68915   int jresult ;
68916   int result;
68917
68918   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
68919   jresult = (int)result;
68920   return jresult;
68921 }
68922
68923
68924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
68925   int jresult ;
68926   int result;
68927
68928   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
68929   jresult = (int)result;
68930   return jresult;
68931 }
68932
68933
68934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
68935   int jresult ;
68936   int result;
68937
68938   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
68939   jresult = (int)result;
68940   return jresult;
68941 }
68942
68943
68944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
68945   int jresult ;
68946   int result;
68947
68948   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
68949   jresult = (int)result;
68950   return jresult;
68951 }
68952
68953
68954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
68955   int jresult ;
68956   int result;
68957
68958   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
68959   jresult = (int)result;
68960   return jresult;
68961 }
68962
68963
68964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
68965   int jresult ;
68966   int result;
68967
68968   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
68969   jresult = (int)result;
68970   return jresult;
68971 }
68972
68973
68974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
68975   int jresult ;
68976   int result;
68977
68978   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
68979   jresult = (int)result;
68980   return jresult;
68981 }
68982
68983
68984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
68985   int jresult ;
68986   int result;
68987
68988   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
68989   jresult = (int)result;
68990   return jresult;
68991 }
68992
68993
68994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
68995   int jresult ;
68996   int result;
68997
68998   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
68999   jresult = (int)result;
69000   return jresult;
69001 }
69002
69003
69004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
69005   int jresult ;
69006   int result;
69007
69008   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
69009   jresult = (int)result;
69010   return jresult;
69011 }
69012
69013
69014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
69015   int jresult ;
69016   int result;
69017
69018   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
69019   jresult = (int)result;
69020   return jresult;
69021 }
69022
69023
69024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
69025   int jresult ;
69026   int result;
69027
69028   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
69029   jresult = (int)result;
69030   return jresult;
69031 }
69032
69033
69034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
69035   int jresult ;
69036   int result;
69037
69038   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
69039   jresult = (int)result;
69040   return jresult;
69041 }
69042
69043
69044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
69045   int jresult ;
69046   int result;
69047
69048   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
69049   jresult = (int)result;
69050   return jresult;
69051 }
69052
69053
69054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
69055   int jresult ;
69056   int result;
69057
69058   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
69059   jresult = (int)result;
69060   return jresult;
69061 }
69062
69063
69064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
69065   int jresult ;
69066   int result;
69067
69068   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
69069   jresult = (int)result;
69070   return jresult;
69071 }
69072
69073
69074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
69075   int jresult ;
69076   int result;
69077
69078   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
69079   jresult = (int)result;
69080   return jresult;
69081 }
69082
69083
69084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
69085   void * jresult ;
69086   Dali::Toolkit::ScrollView::Property *result = 0 ;
69087
69088   {
69089     try {
69090       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
69091     } catch (std::out_of_range& e) {
69092       {
69093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69094       };
69095     } catch (std::exception& e) {
69096       {
69097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69098       };
69099     } catch (...) {
69100       {
69101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69102       };
69103     }
69104   }
69105   jresult = (void *)result;
69106   return jresult;
69107 }
69108
69109
69110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
69111   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
69112
69113   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
69114   {
69115     try {
69116       delete arg1;
69117     } catch (std::out_of_range& e) {
69118       {
69119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69120       };
69121     } catch (std::exception& e) {
69122       {
69123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69124       };
69125     } catch (...) {
69126       {
69127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69128       };
69129     }
69130   }
69131 }
69132
69133
69134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
69135   void * jresult ;
69136   Dali::Toolkit::ScrollView *result = 0 ;
69137
69138   {
69139     try {
69140       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
69141     } catch (std::out_of_range& e) {
69142       {
69143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69144       };
69145     } catch (std::exception& e) {
69146       {
69147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69148       };
69149     } catch (...) {
69150       {
69151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69152       };
69153     }
69154   }
69155   jresult = (void *)result;
69156   return jresult;
69157 }
69158
69159
69160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
69161   void * jresult ;
69162   Dali::Toolkit::ScrollView *arg1 = 0 ;
69163   Dali::Toolkit::ScrollView *result = 0 ;
69164
69165   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69166   if (!arg1) {
69167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
69168     return 0;
69169   }
69170   {
69171     try {
69172       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
69173     } catch (std::out_of_range& e) {
69174       {
69175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69176       };
69177     } catch (std::exception& e) {
69178       {
69179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69180       };
69181     } catch (...) {
69182       {
69183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69184       };
69185     }
69186   }
69187   jresult = (void *)result;
69188   return jresult;
69189 }
69190
69191
69192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
69193   void * jresult ;
69194   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69195   Dali::Toolkit::ScrollView *arg2 = 0 ;
69196   Dali::Toolkit::ScrollView *result = 0 ;
69197
69198   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69199   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
69200   if (!arg2) {
69201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
69202     return 0;
69203   }
69204   {
69205     try {
69206       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
69207     } catch (std::out_of_range& e) {
69208       {
69209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69210       };
69211     } catch (std::exception& e) {
69212       {
69213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69214       };
69215     } catch (...) {
69216       {
69217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69218       };
69219     }
69220   }
69221   jresult = (void *)result;
69222   return jresult;
69223 }
69224
69225
69226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
69227   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69228
69229   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69230   {
69231     try {
69232       delete arg1;
69233     } catch (std::out_of_range& e) {
69234       {
69235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69236       };
69237     } catch (std::exception& e) {
69238       {
69239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69240       };
69241     } catch (...) {
69242       {
69243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69244       };
69245     }
69246   }
69247 }
69248
69249
69250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
69251   void * jresult ;
69252   Dali::Toolkit::ScrollView result;
69253
69254   {
69255     try {
69256       result = Dali::Toolkit::ScrollView::New();
69257     } catch (std::out_of_range& e) {
69258       {
69259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69260       };
69261     } catch (std::exception& e) {
69262       {
69263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69264       };
69265     } catch (...) {
69266       {
69267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69268       };
69269     }
69270   }
69271   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
69272   return jresult;
69273 }
69274
69275
69276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
69277   void * jresult ;
69278   Dali::BaseHandle arg1 ;
69279   Dali::BaseHandle *argp1 ;
69280   Dali::Toolkit::ScrollView result;
69281
69282   argp1 = (Dali::BaseHandle *)jarg1;
69283   if (!argp1) {
69284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69285     return 0;
69286   }
69287   arg1 = *argp1;
69288   {
69289     try {
69290       result = Dali::Toolkit::ScrollView::DownCast(arg1);
69291     } catch (std::out_of_range& e) {
69292       {
69293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69294       };
69295     } catch (std::exception& e) {
69296       {
69297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69298       };
69299     } catch (...) {
69300       {
69301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69302       };
69303     }
69304   }
69305   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
69306   return jresult;
69307 }
69308
69309
69310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
69311   void * jresult ;
69312   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69313   Dali::AlphaFunction result;
69314
69315   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69316   {
69317     try {
69318       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
69319     } catch (std::out_of_range& e) {
69320       {
69321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69322       };
69323     } catch (std::exception& e) {
69324       {
69325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69326       };
69327     } catch (...) {
69328       {
69329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69330       };
69331     }
69332   }
69333   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
69334   return jresult;
69335 }
69336
69337
69338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
69339   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69340   Dali::AlphaFunction arg2 ;
69341   Dali::AlphaFunction *argp2 ;
69342
69343   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69344   argp2 = (Dali::AlphaFunction *)jarg2;
69345   if (!argp2) {
69346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69347     return ;
69348   }
69349   arg2 = *argp2;
69350   {
69351     try {
69352       (arg1)->SetScrollSnapAlphaFunction(arg2);
69353     } catch (std::out_of_range& e) {
69354       {
69355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69356       };
69357     } catch (std::exception& e) {
69358       {
69359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69360       };
69361     } catch (...) {
69362       {
69363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69364       };
69365     }
69366   }
69367 }
69368
69369
69370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
69371   void * jresult ;
69372   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69373   Dali::AlphaFunction result;
69374
69375   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69376   {
69377     try {
69378       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
69379     } catch (std::out_of_range& e) {
69380       {
69381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69382       };
69383     } catch (std::exception& e) {
69384       {
69385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69386       };
69387     } catch (...) {
69388       {
69389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69390       };
69391     }
69392   }
69393   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
69394   return jresult;
69395 }
69396
69397
69398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
69399   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69400   Dali::AlphaFunction arg2 ;
69401   Dali::AlphaFunction *argp2 ;
69402
69403   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69404   argp2 = (Dali::AlphaFunction *)jarg2;
69405   if (!argp2) {
69406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69407     return ;
69408   }
69409   arg2 = *argp2;
69410   {
69411     try {
69412       (arg1)->SetScrollFlickAlphaFunction(arg2);
69413     } catch (std::out_of_range& e) {
69414       {
69415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69416       };
69417     } catch (std::exception& e) {
69418       {
69419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69420       };
69421     } catch (...) {
69422       {
69423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69424       };
69425     }
69426   }
69427 }
69428
69429
69430 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
69431   float jresult ;
69432   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69433   float result;
69434
69435   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69436   {
69437     try {
69438       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
69439     } catch (std::out_of_range& e) {
69440       {
69441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69442       };
69443     } catch (std::exception& e) {
69444       {
69445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69446       };
69447     } catch (...) {
69448       {
69449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69450       };
69451     }
69452   }
69453   jresult = result;
69454   return jresult;
69455 }
69456
69457
69458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
69459   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69460   float arg2 ;
69461
69462   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69463   arg2 = (float)jarg2;
69464   {
69465     try {
69466       (arg1)->SetScrollSnapDuration(arg2);
69467     } catch (std::out_of_range& e) {
69468       {
69469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69470       };
69471     } catch (std::exception& e) {
69472       {
69473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69474       };
69475     } catch (...) {
69476       {
69477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69478       };
69479     }
69480   }
69481 }
69482
69483
69484 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
69485   float jresult ;
69486   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69487   float result;
69488
69489   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69490   {
69491     try {
69492       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
69493     } catch (std::out_of_range& e) {
69494       {
69495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69496       };
69497     } catch (std::exception& e) {
69498       {
69499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69500       };
69501     } catch (...) {
69502       {
69503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69504       };
69505     }
69506   }
69507   jresult = result;
69508   return jresult;
69509 }
69510
69511
69512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
69513   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69514   float arg2 ;
69515
69516   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69517   arg2 = (float)jarg2;
69518   {
69519     try {
69520       (arg1)->SetScrollFlickDuration(arg2);
69521     } catch (std::out_of_range& e) {
69522       {
69523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69524       };
69525     } catch (std::exception& e) {
69526       {
69527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69528       };
69529     } catch (...) {
69530       {
69531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69532       };
69533     }
69534   }
69535 }
69536
69537
69538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
69539   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69540   Dali::Toolkit::RulerPtr arg2 ;
69541   Dali::Toolkit::RulerPtr *argp2 ;
69542
69543   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69544   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
69545   if (!argp2) {
69546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
69547     return ;
69548   }
69549   arg2 = *argp2;
69550   {
69551     try {
69552       (arg1)->SetRulerX(arg2);
69553     } catch (std::out_of_range& e) {
69554       {
69555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69556       };
69557     } catch (std::exception& e) {
69558       {
69559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69560       };
69561     } catch (...) {
69562       {
69563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69564       };
69565     }
69566   }
69567 }
69568
69569
69570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
69571   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69572   Dali::Toolkit::RulerPtr arg2 ;
69573   Dali::Toolkit::RulerPtr *argp2 ;
69574
69575   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69576   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
69577   if (!argp2) {
69578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
69579     return ;
69580   }
69581   arg2 = *argp2;
69582   {
69583     try {
69584       (arg1)->SetRulerY(arg2);
69585     } catch (std::out_of_range& e) {
69586       {
69587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69588       };
69589     } catch (std::exception& e) {
69590       {
69591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69592       };
69593     } catch (...) {
69594       {
69595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69596       };
69597     }
69598   }
69599 }
69600
69601
69602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
69603   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69604   bool arg2 ;
69605
69606   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69607   arg2 = jarg2 ? true : false;
69608   {
69609     try {
69610       (arg1)->SetScrollSensitive(arg2);
69611     } catch (std::out_of_range& e) {
69612       {
69613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69614       };
69615     } catch (std::exception& e) {
69616       {
69617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69618       };
69619     } catch (...) {
69620       {
69621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69622       };
69623     }
69624   }
69625 }
69626
69627
69628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
69629   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69630   float arg2 ;
69631   float arg3 ;
69632
69633   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69634   arg2 = (float)jarg2;
69635   arg3 = (float)jarg3;
69636   {
69637     try {
69638       (arg1)->SetMaxOvershoot(arg2,arg3);
69639     } catch (std::out_of_range& e) {
69640       {
69641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69642       };
69643     } catch (std::exception& e) {
69644       {
69645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69646       };
69647     } catch (...) {
69648       {
69649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69650       };
69651     }
69652   }
69653 }
69654
69655
69656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
69657   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69658   Dali::AlphaFunction arg2 ;
69659   Dali::AlphaFunction *argp2 ;
69660
69661   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69662   argp2 = (Dali::AlphaFunction *)jarg2;
69663   if (!argp2) {
69664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69665     return ;
69666   }
69667   arg2 = *argp2;
69668   {
69669     try {
69670       (arg1)->SetSnapOvershootAlphaFunction(arg2);
69671     } catch (std::out_of_range& e) {
69672       {
69673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69674       };
69675     } catch (std::exception& e) {
69676       {
69677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69678       };
69679     } catch (...) {
69680       {
69681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69682       };
69683     }
69684   }
69685 }
69686
69687
69688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
69689   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69690   float arg2 ;
69691
69692   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69693   arg2 = (float)jarg2;
69694   {
69695     try {
69696       (arg1)->SetSnapOvershootDuration(arg2);
69697     } catch (std::out_of_range& e) {
69698       {
69699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69700       };
69701     } catch (std::exception& e) {
69702       {
69703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69704       };
69705     } catch (...) {
69706       {
69707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69708       };
69709     }
69710   }
69711 }
69712
69713
69714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
69715   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69716   bool arg2 ;
69717
69718   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69719   arg2 = jarg2 ? true : false;
69720   {
69721     try {
69722       (arg1)->SetActorAutoSnap(arg2);
69723     } catch (std::out_of_range& e) {
69724       {
69725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69726       };
69727     } catch (std::exception& e) {
69728       {
69729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69730       };
69731     } catch (...) {
69732       {
69733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69734       };
69735     }
69736   }
69737 }
69738
69739
69740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
69741   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69742   bool arg2 ;
69743
69744   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69745   arg2 = jarg2 ? true : false;
69746   {
69747     try {
69748       (arg1)->SetWrapMode(arg2);
69749     } catch (std::out_of_range& e) {
69750       {
69751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69752       };
69753     } catch (std::exception& e) {
69754       {
69755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69756       };
69757     } catch (...) {
69758       {
69759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69760       };
69761     }
69762   }
69763 }
69764
69765
69766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
69767   int jresult ;
69768   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69769   int result;
69770
69771   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69772   {
69773     try {
69774       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
69775     } catch (std::out_of_range& e) {
69776       {
69777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69778       };
69779     } catch (std::exception& e) {
69780       {
69781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69782       };
69783     } catch (...) {
69784       {
69785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69786       };
69787     }
69788   }
69789   jresult = result;
69790   return jresult;
69791 }
69792
69793
69794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
69795   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69796   int arg2 ;
69797
69798   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69799   arg2 = (int)jarg2;
69800   {
69801     try {
69802       (arg1)->SetScrollUpdateDistance(arg2);
69803     } catch (std::out_of_range& e) {
69804       {
69805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69806       };
69807     } catch (std::exception& e) {
69808       {
69809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69810       };
69811     } catch (...) {
69812       {
69813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69814       };
69815     }
69816   }
69817 }
69818
69819
69820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
69821   unsigned int jresult ;
69822   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69823   bool result;
69824
69825   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69826   {
69827     try {
69828       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
69829     } catch (std::out_of_range& e) {
69830       {
69831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69832       };
69833     } catch (std::exception& e) {
69834       {
69835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69836       };
69837     } catch (...) {
69838       {
69839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69840       };
69841     }
69842   }
69843   jresult = result;
69844   return jresult;
69845 }
69846
69847
69848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
69849   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69850   bool arg2 ;
69851
69852   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69853   arg2 = jarg2 ? true : false;
69854   {
69855     try {
69856       (arg1)->SetAxisAutoLock(arg2);
69857     } catch (std::out_of_range& e) {
69858       {
69859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69860       };
69861     } catch (std::exception& e) {
69862       {
69863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69864       };
69865     } catch (...) {
69866       {
69867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69868       };
69869     }
69870   }
69871 }
69872
69873
69874 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
69875   float jresult ;
69876   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69877   float result;
69878
69879   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69880   {
69881     try {
69882       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
69883     } catch (std::out_of_range& e) {
69884       {
69885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69886       };
69887     } catch (std::exception& e) {
69888       {
69889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69890       };
69891     } catch (...) {
69892       {
69893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69894       };
69895     }
69896   }
69897   jresult = result;
69898   return jresult;
69899 }
69900
69901
69902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
69903   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69904   float arg2 ;
69905
69906   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69907   arg2 = (float)jarg2;
69908   {
69909     try {
69910       (arg1)->SetAxisAutoLockGradient(arg2);
69911     } catch (std::out_of_range& e) {
69912       {
69913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69914       };
69915     } catch (std::exception& e) {
69916       {
69917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69918       };
69919     } catch (...) {
69920       {
69921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69922       };
69923     }
69924   }
69925 }
69926
69927
69928 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
69929   float jresult ;
69930   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69931   float result;
69932
69933   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69934   {
69935     try {
69936       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
69937     } catch (std::out_of_range& e) {
69938       {
69939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69940       };
69941     } catch (std::exception& e) {
69942       {
69943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69944       };
69945     } catch (...) {
69946       {
69947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69948       };
69949     }
69950   }
69951   jresult = result;
69952   return jresult;
69953 }
69954
69955
69956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
69957   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69958   float arg2 ;
69959
69960   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69961   arg2 = (float)jarg2;
69962   {
69963     try {
69964       (arg1)->SetFrictionCoefficient(arg2);
69965     } catch (std::out_of_range& e) {
69966       {
69967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69968       };
69969     } catch (std::exception& e) {
69970       {
69971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69972       };
69973     } catch (...) {
69974       {
69975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69976       };
69977     }
69978   }
69979 }
69980
69981
69982 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
69983   float jresult ;
69984   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69985   float result;
69986
69987   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69988   {
69989     try {
69990       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
69991     } catch (std::out_of_range& e) {
69992       {
69993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69994       };
69995     } catch (std::exception& e) {
69996       {
69997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69998       };
69999     } catch (...) {
70000       {
70001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70002       };
70003     }
70004   }
70005   jresult = result;
70006   return jresult;
70007 }
70008
70009
70010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
70011   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70012   float arg2 ;
70013
70014   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70015   arg2 = (float)jarg2;
70016   {
70017     try {
70018       (arg1)->SetFlickSpeedCoefficient(arg2);
70019     } catch (std::out_of_range& e) {
70020       {
70021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70022       };
70023     } catch (std::exception& e) {
70024       {
70025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70026       };
70027     } catch (...) {
70028       {
70029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70030       };
70031     }
70032   }
70033 }
70034
70035
70036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
70037   void * jresult ;
70038   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70039   Dali::Vector2 result;
70040
70041   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70042   {
70043     try {
70044       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
70045     } catch (std::out_of_range& e) {
70046       {
70047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70048       };
70049     } catch (std::exception& e) {
70050       {
70051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70052       };
70053     } catch (...) {
70054       {
70055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70056       };
70057     }
70058   }
70059   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70060   return jresult;
70061 }
70062
70063
70064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
70065   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70066   Dali::Vector2 *arg2 = 0 ;
70067
70068   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70069   arg2 = (Dali::Vector2 *)jarg2;
70070   if (!arg2) {
70071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70072     return ;
70073   }
70074   {
70075     try {
70076       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
70077     } catch (std::out_of_range& e) {
70078       {
70079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70080       };
70081     } catch (std::exception& e) {
70082       {
70083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70084       };
70085     } catch (...) {
70086       {
70087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70088       };
70089     }
70090   }
70091 }
70092
70093
70094 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
70095   float jresult ;
70096   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70097   float result;
70098
70099   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70100   {
70101     try {
70102       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
70103     } catch (std::out_of_range& e) {
70104       {
70105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70106       };
70107     } catch (std::exception& e) {
70108       {
70109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70110       };
70111     } catch (...) {
70112       {
70113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70114       };
70115     }
70116   }
70117   jresult = result;
70118   return jresult;
70119 }
70120
70121
70122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
70123   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70124   float arg2 ;
70125
70126   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70127   arg2 = (float)jarg2;
70128   {
70129     try {
70130       (arg1)->SetMinimumSpeedForFlick(arg2);
70131     } catch (std::out_of_range& e) {
70132       {
70133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70134       };
70135     } catch (std::exception& e) {
70136       {
70137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70138       };
70139     } catch (...) {
70140       {
70141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70142       };
70143     }
70144   }
70145 }
70146
70147
70148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
70149   float jresult ;
70150   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70151   float result;
70152
70153   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70154   {
70155     try {
70156       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
70157     } catch (std::out_of_range& e) {
70158       {
70159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70160       };
70161     } catch (std::exception& e) {
70162       {
70163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70164       };
70165     } catch (...) {
70166       {
70167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70168       };
70169     }
70170   }
70171   jresult = result;
70172   return jresult;
70173 }
70174
70175
70176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
70177   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70178   float arg2 ;
70179
70180   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70181   arg2 = (float)jarg2;
70182   {
70183     try {
70184       (arg1)->SetMaxFlickSpeed(arg2);
70185     } catch (std::out_of_range& e) {
70186       {
70187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70188       };
70189     } catch (std::exception& e) {
70190       {
70191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70192       };
70193     } catch (...) {
70194       {
70195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70196       };
70197     }
70198   }
70199 }
70200
70201
70202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
70203   void * jresult ;
70204   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70205   Dali::Vector2 result;
70206
70207   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70208   {
70209     try {
70210       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
70211     } catch (std::out_of_range& e) {
70212       {
70213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70214       };
70215     } catch (std::exception& e) {
70216       {
70217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70218       };
70219     } catch (...) {
70220       {
70221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70222       };
70223     }
70224   }
70225   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70226   return jresult;
70227 }
70228
70229
70230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
70231   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70232   Dali::Vector2 arg2 ;
70233   Dali::Vector2 *argp2 ;
70234
70235   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70236   argp2 = (Dali::Vector2 *)jarg2;
70237   if (!argp2) {
70238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
70239     return ;
70240   }
70241   arg2 = *argp2;
70242   {
70243     try {
70244       (arg1)->SetWheelScrollDistanceStep(arg2);
70245     } catch (std::out_of_range& e) {
70246       {
70247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70248       };
70249     } catch (std::exception& e) {
70250       {
70251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70252       };
70253     } catch (...) {
70254       {
70255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70256       };
70257     }
70258   }
70259 }
70260
70261
70262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
70263   void * jresult ;
70264   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70265   Dali::Vector2 result;
70266
70267   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70268   {
70269     try {
70270       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
70271     } catch (std::out_of_range& e) {
70272       {
70273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70274       };
70275     } catch (std::exception& e) {
70276       {
70277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70278       };
70279     } catch (...) {
70280       {
70281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70282       };
70283     }
70284   }
70285   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70286   return jresult;
70287 }
70288
70289
70290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
70291   unsigned int jresult ;
70292   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70293   unsigned int result;
70294
70295   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70296   {
70297     try {
70298       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
70299     } catch (std::out_of_range& e) {
70300       {
70301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70302       };
70303     } catch (std::exception& e) {
70304       {
70305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70306       };
70307     } catch (...) {
70308       {
70309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70310       };
70311     }
70312   }
70313   jresult = result;
70314   return jresult;
70315 }
70316
70317
70318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
70319   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70320   Dali::Vector2 *arg2 = 0 ;
70321
70322   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70323   arg2 = (Dali::Vector2 *)jarg2;
70324   if (!arg2) {
70325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70326     return ;
70327   }
70328   {
70329     try {
70330       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
70331     } catch (std::out_of_range& e) {
70332       {
70333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70334       };
70335     } catch (std::exception& e) {
70336       {
70337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70338       };
70339     } catch (...) {
70340       {
70341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70342       };
70343     }
70344   }
70345 }
70346
70347
70348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
70349   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70350   Dali::Vector2 *arg2 = 0 ;
70351   float arg3 ;
70352
70353   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70354   arg2 = (Dali::Vector2 *)jarg2;
70355   if (!arg2) {
70356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70357     return ;
70358   }
70359   arg3 = (float)jarg3;
70360   {
70361     try {
70362       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
70363     } catch (std::out_of_range& e) {
70364       {
70365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70366       };
70367     } catch (std::exception& e) {
70368       {
70369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70370       };
70371     } catch (...) {
70372       {
70373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70374       };
70375     }
70376   }
70377 }
70378
70379
70380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
70381   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70382   Dali::Vector2 *arg2 = 0 ;
70383   float arg3 ;
70384   Dali::AlphaFunction arg4 ;
70385   Dali::AlphaFunction *argp4 ;
70386
70387   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70388   arg2 = (Dali::Vector2 *)jarg2;
70389   if (!arg2) {
70390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70391     return ;
70392   }
70393   arg3 = (float)jarg3;
70394   argp4 = (Dali::AlphaFunction *)jarg4;
70395   if (!argp4) {
70396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
70397     return ;
70398   }
70399   arg4 = *argp4;
70400   {
70401     try {
70402       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
70403     } catch (std::out_of_range& e) {
70404       {
70405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70406       };
70407     } catch (std::exception& e) {
70408       {
70409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70410       };
70411     } catch (...) {
70412       {
70413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70414       };
70415     }
70416   }
70417 }
70418
70419
70420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
70421   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70422   Dali::Vector2 *arg2 = 0 ;
70423   float arg3 ;
70424   Dali::Toolkit::DirectionBias arg4 ;
70425   Dali::Toolkit::DirectionBias arg5 ;
70426
70427   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70428   arg2 = (Dali::Vector2 *)jarg2;
70429   if (!arg2) {
70430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70431     return ;
70432   }
70433   arg3 = (float)jarg3;
70434   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
70435   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
70436   {
70437     try {
70438       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
70439     } catch (std::out_of_range& e) {
70440       {
70441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70442       };
70443     } catch (std::exception& e) {
70444       {
70445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70446       };
70447     } catch (...) {
70448       {
70449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70450       };
70451     }
70452   }
70453 }
70454
70455
70456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
70457   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70458   Dali::Vector2 *arg2 = 0 ;
70459   float arg3 ;
70460   Dali::AlphaFunction arg4 ;
70461   Dali::Toolkit::DirectionBias arg5 ;
70462   Dali::Toolkit::DirectionBias arg6 ;
70463   Dali::AlphaFunction *argp4 ;
70464
70465   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70466   arg2 = (Dali::Vector2 *)jarg2;
70467   if (!arg2) {
70468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70469     return ;
70470   }
70471   arg3 = (float)jarg3;
70472   argp4 = (Dali::AlphaFunction *)jarg4;
70473   if (!argp4) {
70474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
70475     return ;
70476   }
70477   arg4 = *argp4;
70478   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
70479   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
70480   {
70481     try {
70482       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
70483     } catch (std::out_of_range& e) {
70484       {
70485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70486       };
70487     } catch (std::exception& e) {
70488       {
70489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70490       };
70491     } catch (...) {
70492       {
70493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70494       };
70495     }
70496   }
70497 }
70498
70499
70500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
70501   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70502   unsigned int arg2 ;
70503
70504   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70505   arg2 = (unsigned int)jarg2;
70506   {
70507     try {
70508       (arg1)->ScrollTo(arg2);
70509     } catch (std::out_of_range& e) {
70510       {
70511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70512       };
70513     } catch (std::exception& e) {
70514       {
70515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70516       };
70517     } catch (...) {
70518       {
70519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70520       };
70521     }
70522   }
70523 }
70524
70525
70526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
70527   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70528   unsigned int arg2 ;
70529   float arg3 ;
70530
70531   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70532   arg2 = (unsigned int)jarg2;
70533   arg3 = (float)jarg3;
70534   {
70535     try {
70536       (arg1)->ScrollTo(arg2,arg3);
70537     } catch (std::out_of_range& e) {
70538       {
70539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70540       };
70541     } catch (std::exception& e) {
70542       {
70543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70544       };
70545     } catch (...) {
70546       {
70547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70548       };
70549     }
70550   }
70551 }
70552
70553
70554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
70555   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70556   unsigned int arg2 ;
70557   float arg3 ;
70558   Dali::Toolkit::DirectionBias arg4 ;
70559
70560   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70561   arg2 = (unsigned int)jarg2;
70562   arg3 = (float)jarg3;
70563   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
70564   {
70565     try {
70566       (arg1)->ScrollTo(arg2,arg3,arg4);
70567     } catch (std::out_of_range& e) {
70568       {
70569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70570       };
70571     } catch (std::exception& e) {
70572       {
70573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70574       };
70575     } catch (...) {
70576       {
70577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70578       };
70579     }
70580   }
70581 }
70582
70583
70584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
70585   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70586   Dali::Actor *arg2 = 0 ;
70587
70588   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70589   arg2 = (Dali::Actor *)jarg2;
70590   if (!arg2) {
70591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70592     return ;
70593   }
70594   {
70595     try {
70596       (arg1)->ScrollTo(*arg2);
70597     } catch (std::out_of_range& e) {
70598       {
70599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70600       };
70601     } catch (std::exception& e) {
70602       {
70603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70604       };
70605     } catch (...) {
70606       {
70607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70608       };
70609     }
70610   }
70611 }
70612
70613
70614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
70615   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70616   Dali::Actor *arg2 = 0 ;
70617   float arg3 ;
70618
70619   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70620   arg2 = (Dali::Actor *)jarg2;
70621   if (!arg2) {
70622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70623     return ;
70624   }
70625   arg3 = (float)jarg3;
70626   {
70627     try {
70628       (arg1)->ScrollTo(*arg2,arg3);
70629     } catch (std::out_of_range& e) {
70630       {
70631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70632       };
70633     } catch (std::exception& e) {
70634       {
70635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70636       };
70637     } catch (...) {
70638       {
70639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70640       };
70641     }
70642   }
70643 }
70644
70645
70646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
70647   unsigned int jresult ;
70648   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70649   bool result;
70650
70651   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70652   {
70653     try {
70654       result = (bool)(arg1)->ScrollToSnapPoint();
70655     } catch (std::out_of_range& e) {
70656       {
70657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70658       };
70659     } catch (std::exception& e) {
70660       {
70661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70662       };
70663     } catch (...) {
70664       {
70665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70666       };
70667     }
70668   }
70669   jresult = result;
70670   return jresult;
70671 }
70672
70673
70674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
70675   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70676   Dali::Constraint arg2 ;
70677   Dali::Constraint *argp2 ;
70678
70679   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70680   argp2 = (Dali::Constraint *)jarg2;
70681   if (!argp2) {
70682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
70683     return ;
70684   }
70685   arg2 = *argp2;
70686   {
70687     try {
70688       (arg1)->ApplyConstraintToChildren(arg2);
70689     } catch (std::out_of_range& e) {
70690       {
70691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70692       };
70693     } catch (std::exception& e) {
70694       {
70695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70696       };
70697     } catch (...) {
70698       {
70699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70700       };
70701     }
70702   }
70703 }
70704
70705
70706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
70707   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70708
70709   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70710   {
70711     try {
70712       (arg1)->RemoveConstraintsFromChildren();
70713     } catch (std::out_of_range& e) {
70714       {
70715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70716       };
70717     } catch (std::exception& e) {
70718       {
70719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70720       };
70721     } catch (...) {
70722       {
70723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70724       };
70725     }
70726   }
70727 }
70728
70729
70730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
70731   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70732   Dali::Toolkit::ScrollViewEffect arg2 ;
70733   Dali::Toolkit::ScrollViewEffect *argp2 ;
70734
70735   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70736   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
70737   if (!argp2) {
70738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
70739     return ;
70740   }
70741   arg2 = *argp2;
70742   {
70743     try {
70744       (arg1)->ApplyEffect(arg2);
70745     } catch (std::out_of_range& e) {
70746       {
70747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70748       };
70749     } catch (std::exception& e) {
70750       {
70751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70752       };
70753     } catch (...) {
70754       {
70755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70756       };
70757     }
70758   }
70759 }
70760
70761
70762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
70763   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70764   Dali::Toolkit::ScrollViewEffect arg2 ;
70765   Dali::Toolkit::ScrollViewEffect *argp2 ;
70766
70767   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70768   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
70769   if (!argp2) {
70770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
70771     return ;
70772   }
70773   arg2 = *argp2;
70774   {
70775     try {
70776       (arg1)->RemoveEffect(arg2);
70777     } catch (std::out_of_range& e) {
70778       {
70779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70780       };
70781     } catch (std::exception& e) {
70782       {
70783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70784       };
70785     } catch (...) {
70786       {
70787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70788       };
70789     }
70790   }
70791 }
70792
70793
70794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
70795   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70796
70797   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70798   {
70799     try {
70800       (arg1)->RemoveAllEffects();
70801     } catch (std::out_of_range& e) {
70802       {
70803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70804       };
70805     } catch (std::exception& e) {
70806       {
70807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70808       };
70809     } catch (...) {
70810       {
70811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70812       };
70813     }
70814   }
70815 }
70816
70817
70818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
70819   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70820   Dali::Actor arg2 ;
70821   Dali::Actor *argp2 ;
70822
70823   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70824   argp2 = (Dali::Actor *)jarg2;
70825   if (!argp2) {
70826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70827     return ;
70828   }
70829   arg2 = *argp2;
70830   {
70831     try {
70832       (arg1)->BindActor(arg2);
70833     } catch (std::out_of_range& e) {
70834       {
70835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70836       };
70837     } catch (std::exception& e) {
70838       {
70839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70840       };
70841     } catch (...) {
70842       {
70843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70844       };
70845     }
70846   }
70847 }
70848
70849
70850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
70851   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70852   Dali::Actor arg2 ;
70853   Dali::Actor *argp2 ;
70854
70855   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70856   argp2 = (Dali::Actor *)jarg2;
70857   if (!argp2) {
70858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70859     return ;
70860   }
70861   arg2 = *argp2;
70862   {
70863     try {
70864       (arg1)->UnbindActor(arg2);
70865     } catch (std::out_of_range& e) {
70866       {
70867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70868       };
70869     } catch (std::exception& e) {
70870       {
70871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70872       };
70873     } catch (...) {
70874       {
70875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70876       };
70877     }
70878   }
70879 }
70880
70881
70882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
70883   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70884   Dali::Radian arg2 ;
70885   Dali::Radian arg3 ;
70886   Dali::Radian *argp2 ;
70887   Dali::Radian *argp3 ;
70888
70889   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70890   argp2 = (Dali::Radian *)jarg2;
70891   if (!argp2) {
70892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70893     return ;
70894   }
70895   arg2 = *argp2;
70896   argp3 = (Dali::Radian *)jarg3;
70897   if (!argp3) {
70898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70899     return ;
70900   }
70901   arg3 = *argp3;
70902   {
70903     try {
70904       (arg1)->SetScrollingDirection(arg2,arg3);
70905     } catch (std::out_of_range& e) {
70906       {
70907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70908       };
70909     } catch (std::exception& e) {
70910       {
70911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70912       };
70913     } catch (...) {
70914       {
70915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70916       };
70917     }
70918   }
70919 }
70920
70921
70922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
70923   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70924   Dali::Radian arg2 ;
70925   Dali::Radian *argp2 ;
70926
70927   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70928   argp2 = (Dali::Radian *)jarg2;
70929   if (!argp2) {
70930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70931     return ;
70932   }
70933   arg2 = *argp2;
70934   {
70935     try {
70936       (arg1)->SetScrollingDirection(arg2);
70937     } catch (std::out_of_range& e) {
70938       {
70939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70940       };
70941     } catch (std::exception& e) {
70942       {
70943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70944       };
70945     } catch (...) {
70946       {
70947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70948       };
70949     }
70950   }
70951 }
70952
70953
70954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
70955   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70956   Dali::Radian arg2 ;
70957   Dali::Radian *argp2 ;
70958
70959   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70960   argp2 = (Dali::Radian *)jarg2;
70961   if (!argp2) {
70962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70963     return ;
70964   }
70965   arg2 = *argp2;
70966   {
70967     try {
70968       (arg1)->RemoveScrollingDirection(arg2);
70969     } catch (std::out_of_range& e) {
70970       {
70971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70972       };
70973     } catch (std::exception& e) {
70974       {
70975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70976       };
70977     } catch (...) {
70978       {
70979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70980       };
70981     }
70982   }
70983 }
70984
70985
70986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
70987   void * jresult ;
70988   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70989   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
70990
70991   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70992   {
70993     try {
70994       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
70995     } catch (std::out_of_range& e) {
70996       {
70997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70998       };
70999     } catch (std::exception& e) {
71000       {
71001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71002       };
71003     } catch (...) {
71004       {
71005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71006       };
71007     }
71008   }
71009   jresult = (void *)result;
71010   return jresult;
71011 }
71012
71013
71014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
71015   int jresult ;
71016   int result;
71017
71018   result = (int)Dali::Toolkit::TableView::Property::ROWS;
71019   jresult = (int)result;
71020   return jresult;
71021 }
71022
71023
71024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
71025   int jresult ;
71026   int result;
71027
71028   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
71029   jresult = (int)result;
71030   return jresult;
71031 }
71032
71033
71034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
71035   int jresult ;
71036   int result;
71037
71038   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
71039   jresult = (int)result;
71040   return jresult;
71041 }
71042
71043
71044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
71045   int jresult ;
71046   int result;
71047
71048   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
71049   jresult = (int)result;
71050   return jresult;
71051 }
71052
71053
71054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
71055   int jresult ;
71056   int result;
71057
71058   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
71059   jresult = (int)result;
71060   return jresult;
71061 }
71062
71063
71064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
71065   void * jresult ;
71066   Dali::Toolkit::TableView::Property *result = 0 ;
71067
71068   {
71069     try {
71070       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
71071     } catch (std::out_of_range& e) {
71072       {
71073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71074       };
71075     } catch (std::exception& e) {
71076       {
71077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71078       };
71079     } catch (...) {
71080       {
71081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71082       };
71083     }
71084   }
71085   jresult = (void *)result;
71086   return jresult;
71087 }
71088
71089
71090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
71091   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
71092
71093   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
71094   {
71095     try {
71096       delete arg1;
71097     } catch (std::out_of_range& e) {
71098       {
71099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71100       };
71101     } catch (std::exception& e) {
71102       {
71103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71104       };
71105     } catch (...) {
71106       {
71107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71108       };
71109     }
71110   }
71111 }
71112
71113
71114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
71115   int jresult ;
71116   int result;
71117
71118   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
71119   jresult = (int)result;
71120   return jresult;
71121 }
71122
71123
71124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
71125   int jresult ;
71126   int result;
71127
71128   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
71129   jresult = (int)result;
71130   return jresult;
71131 }
71132
71133
71134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
71135   int jresult ;
71136   int result;
71137
71138   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
71139   jresult = (int)result;
71140   return jresult;
71141 }
71142
71143
71144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
71145   int jresult ;
71146   int result;
71147
71148   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
71149   jresult = (int)result;
71150   return jresult;
71151 }
71152
71153
71154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
71155   int jresult ;
71156   int result;
71157
71158   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
71159   jresult = (int)result;
71160   return jresult;
71161 }
71162
71163
71164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
71165   void * jresult ;
71166   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
71167
71168   {
71169     try {
71170       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
71171     } catch (std::out_of_range& e) {
71172       {
71173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71174       };
71175     } catch (std::exception& e) {
71176       {
71177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71178       };
71179     } catch (...) {
71180       {
71181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71182       };
71183     }
71184   }
71185   jresult = (void *)result;
71186   return jresult;
71187 }
71188
71189
71190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
71191   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
71192
71193   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
71194   {
71195     try {
71196       delete arg1;
71197     } catch (std::out_of_range& e) {
71198       {
71199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71200       };
71201     } catch (std::exception& e) {
71202       {
71203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71204       };
71205     } catch (...) {
71206       {
71207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71208       };
71209     }
71210   }
71211 }
71212
71213
71214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
71215   void * jresult ;
71216   unsigned int arg1 ;
71217   unsigned int arg2 ;
71218   unsigned int arg3 ;
71219   unsigned int arg4 ;
71220   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71221
71222   arg1 = (unsigned int)jarg1;
71223   arg2 = (unsigned int)jarg2;
71224   arg3 = (unsigned int)jarg3;
71225   arg4 = (unsigned int)jarg4;
71226   {
71227     try {
71228       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
71229     } catch (std::out_of_range& e) {
71230       {
71231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71232       };
71233     } catch (std::exception& e) {
71234       {
71235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71236       };
71237     } catch (...) {
71238       {
71239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71240       };
71241     }
71242   }
71243   jresult = (void *)result;
71244   return jresult;
71245 }
71246
71247
71248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
71249   void * jresult ;
71250   unsigned int arg1 ;
71251   unsigned int arg2 ;
71252   unsigned int arg3 ;
71253   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71254
71255   arg1 = (unsigned int)jarg1;
71256   arg2 = (unsigned int)jarg2;
71257   arg3 = (unsigned int)jarg3;
71258   {
71259     try {
71260       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
71261     } catch (std::out_of_range& e) {
71262       {
71263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71264       };
71265     } catch (std::exception& e) {
71266       {
71267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71268       };
71269     } catch (...) {
71270       {
71271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71272       };
71273     }
71274   }
71275   jresult = (void *)result;
71276   return jresult;
71277 }
71278
71279
71280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
71281   void * jresult ;
71282   unsigned int arg1 ;
71283   unsigned int arg2 ;
71284   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71285
71286   arg1 = (unsigned int)jarg1;
71287   arg2 = (unsigned int)jarg2;
71288   {
71289     try {
71290       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
71291     } catch (std::out_of_range& e) {
71292       {
71293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71294       };
71295     } catch (std::exception& e) {
71296       {
71297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71298       };
71299     } catch (...) {
71300       {
71301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71302       };
71303     }
71304   }
71305   jresult = (void *)result;
71306   return jresult;
71307 }
71308
71309
71310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
71311   void * jresult ;
71312   unsigned int arg1 ;
71313   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71314
71315   arg1 = (unsigned int)jarg1;
71316   {
71317     try {
71318       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
71319     } catch (std::out_of_range& e) {
71320       {
71321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71322       };
71323     } catch (std::exception& e) {
71324       {
71325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71326       };
71327     } catch (...) {
71328       {
71329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71330       };
71331     }
71332   }
71333   jresult = (void *)result;
71334   return jresult;
71335 }
71336
71337
71338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
71339   void * jresult ;
71340   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71341
71342   {
71343     try {
71344       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
71345     } catch (std::out_of_range& e) {
71346       {
71347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71348       };
71349     } catch (std::exception& e) {
71350       {
71351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71352       };
71353     } catch (...) {
71354       {
71355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71356       };
71357     }
71358   }
71359   jresult = (void *)result;
71360   return jresult;
71361 }
71362
71363
71364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
71365   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71366   unsigned int arg2 ;
71367
71368   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71369   arg2 = (unsigned int)jarg2;
71370   if (arg1) (arg1)->rowIndex = arg2;
71371 }
71372
71373
71374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
71375   unsigned int jresult ;
71376   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71377   unsigned int result;
71378
71379   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71380   result = (unsigned int) ((arg1)->rowIndex);
71381   jresult = result;
71382   return jresult;
71383 }
71384
71385
71386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
71387   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71388   unsigned int arg2 ;
71389
71390   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71391   arg2 = (unsigned int)jarg2;
71392   if (arg1) (arg1)->columnIndex = arg2;
71393 }
71394
71395
71396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
71397   unsigned int jresult ;
71398   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71399   unsigned int result;
71400
71401   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71402   result = (unsigned int) ((arg1)->columnIndex);
71403   jresult = result;
71404   return jresult;
71405 }
71406
71407
71408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
71409   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71410   unsigned int arg2 ;
71411
71412   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71413   arg2 = (unsigned int)jarg2;
71414   if (arg1) (arg1)->rowSpan = arg2;
71415 }
71416
71417
71418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
71419   unsigned int jresult ;
71420   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71421   unsigned int result;
71422
71423   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71424   result = (unsigned int) ((arg1)->rowSpan);
71425   jresult = result;
71426   return jresult;
71427 }
71428
71429
71430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
71431   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71432   unsigned int arg2 ;
71433
71434   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71435   arg2 = (unsigned int)jarg2;
71436   if (arg1) (arg1)->columnSpan = arg2;
71437 }
71438
71439
71440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
71441   unsigned int jresult ;
71442   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71443   unsigned int result;
71444
71445   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71446   result = (unsigned int) ((arg1)->columnSpan);
71447   jresult = result;
71448   return jresult;
71449 }
71450
71451
71452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
71453   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71454
71455   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71456   {
71457     try {
71458       delete arg1;
71459     } catch (std::out_of_range& e) {
71460       {
71461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71462       };
71463     } catch (std::exception& e) {
71464       {
71465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71466       };
71467     } catch (...) {
71468       {
71469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71470       };
71471     }
71472   }
71473 }
71474
71475
71476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
71477   void * jresult ;
71478   Dali::Toolkit::TableView *result = 0 ;
71479
71480   {
71481     try {
71482       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
71483     } catch (std::out_of_range& e) {
71484       {
71485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71486       };
71487     } catch (std::exception& e) {
71488       {
71489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71490       };
71491     } catch (...) {
71492       {
71493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71494       };
71495     }
71496   }
71497   jresult = (void *)result;
71498   return jresult;
71499 }
71500
71501
71502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
71503   void * jresult ;
71504   Dali::Toolkit::TableView *arg1 = 0 ;
71505   Dali::Toolkit::TableView *result = 0 ;
71506
71507   arg1 = (Dali::Toolkit::TableView *)jarg1;
71508   if (!arg1) {
71509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
71510     return 0;
71511   }
71512   {
71513     try {
71514       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
71515     } catch (std::out_of_range& e) {
71516       {
71517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71518       };
71519     } catch (std::exception& e) {
71520       {
71521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71522       };
71523     } catch (...) {
71524       {
71525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71526       };
71527     }
71528   }
71529   jresult = (void *)result;
71530   return jresult;
71531 }
71532
71533
71534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
71535   void * jresult ;
71536   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71537   Dali::Toolkit::TableView *arg2 = 0 ;
71538   Dali::Toolkit::TableView *result = 0 ;
71539
71540   arg1 = (Dali::Toolkit::TableView *)jarg1;
71541   arg2 = (Dali::Toolkit::TableView *)jarg2;
71542   if (!arg2) {
71543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
71544     return 0;
71545   }
71546   {
71547     try {
71548       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
71549     } catch (std::out_of_range& e) {
71550       {
71551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71552       };
71553     } catch (std::exception& e) {
71554       {
71555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71556       };
71557     } catch (...) {
71558       {
71559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71560       };
71561     }
71562   }
71563   jresult = (void *)result;
71564   return jresult;
71565 }
71566
71567
71568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
71569   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71570
71571   arg1 = (Dali::Toolkit::TableView *)jarg1;
71572   {
71573     try {
71574       delete arg1;
71575     } catch (std::out_of_range& e) {
71576       {
71577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71578       };
71579     } catch (std::exception& e) {
71580       {
71581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71582       };
71583     } catch (...) {
71584       {
71585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71586       };
71587     }
71588   }
71589 }
71590
71591
71592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
71593   void * jresult ;
71594   unsigned int arg1 ;
71595   unsigned int arg2 ;
71596   Dali::Toolkit::TableView result;
71597
71598   arg1 = (unsigned int)jarg1;
71599   arg2 = (unsigned int)jarg2;
71600   {
71601     try {
71602       result = Dali::Toolkit::TableView::New(arg1,arg2);
71603     } catch (std::out_of_range& e) {
71604       {
71605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71606       };
71607     } catch (std::exception& e) {
71608       {
71609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71610       };
71611     } catch (...) {
71612       {
71613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71614       };
71615     }
71616   }
71617   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
71618   return jresult;
71619 }
71620
71621
71622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
71623   void * jresult ;
71624   Dali::BaseHandle arg1 ;
71625   Dali::BaseHandle *argp1 ;
71626   Dali::Toolkit::TableView result;
71627
71628   argp1 = (Dali::BaseHandle *)jarg1;
71629   if (!argp1) {
71630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71631     return 0;
71632   }
71633   arg1 = *argp1;
71634   {
71635     try {
71636       result = Dali::Toolkit::TableView::DownCast(arg1);
71637     } catch (std::out_of_range& e) {
71638       {
71639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71640       };
71641     } catch (std::exception& e) {
71642       {
71643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71644       };
71645     } catch (...) {
71646       {
71647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71648       };
71649     }
71650   }
71651   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
71652   return jresult;
71653 }
71654
71655
71656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
71657   unsigned int jresult ;
71658   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71659   Dali::Actor arg2 ;
71660   Dali::Toolkit::TableView::CellPosition arg3 ;
71661   Dali::Actor *argp2 ;
71662   Dali::Toolkit::TableView::CellPosition *argp3 ;
71663   bool result;
71664
71665   arg1 = (Dali::Toolkit::TableView *)jarg1;
71666   argp2 = (Dali::Actor *)jarg2;
71667   if (!argp2) {
71668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71669     return 0;
71670   }
71671   arg2 = *argp2;
71672   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
71673   if (!argp3) {
71674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71675     return 0;
71676   }
71677   arg3 = *argp3;
71678   {
71679     try {
71680       result = (bool)(arg1)->AddChild(arg2,arg3);
71681     } catch (std::out_of_range& e) {
71682       {
71683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71684       };
71685     } catch (std::exception& e) {
71686       {
71687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71688       };
71689     } catch (...) {
71690       {
71691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71692       };
71693     }
71694   }
71695   jresult = result;
71696   return jresult;
71697 }
71698
71699
71700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
71701   void * jresult ;
71702   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71703   Dali::Toolkit::TableView::CellPosition arg2 ;
71704   Dali::Toolkit::TableView::CellPosition *argp2 ;
71705   Dali::Actor result;
71706
71707   arg1 = (Dali::Toolkit::TableView *)jarg1;
71708   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
71709   if (!argp2) {
71710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71711     return 0;
71712   }
71713   arg2 = *argp2;
71714   {
71715     try {
71716       result = (arg1)->GetChildAt(arg2);
71717     } catch (std::out_of_range& e) {
71718       {
71719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71720       };
71721     } catch (std::exception& e) {
71722       {
71723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71724       };
71725     } catch (...) {
71726       {
71727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71728       };
71729     }
71730   }
71731   jresult = new Dali::Actor((const Dali::Actor &)result);
71732   return jresult;
71733 }
71734
71735
71736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
71737   void * jresult ;
71738   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71739   Dali::Toolkit::TableView::CellPosition arg2 ;
71740   Dali::Toolkit::TableView::CellPosition *argp2 ;
71741   Dali::Actor result;
71742
71743   arg1 = (Dali::Toolkit::TableView *)jarg1;
71744   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
71745   if (!argp2) {
71746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71747     return 0;
71748   }
71749   arg2 = *argp2;
71750   {
71751     try {
71752       result = (arg1)->RemoveChildAt(arg2);
71753     } catch (std::out_of_range& e) {
71754       {
71755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71756       };
71757     } catch (std::exception& e) {
71758       {
71759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71760       };
71761     } catch (...) {
71762       {
71763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71764       };
71765     }
71766   }
71767   jresult = new Dali::Actor((const Dali::Actor &)result);
71768   return jresult;
71769 }
71770
71771
71772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
71773   unsigned int jresult ;
71774   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71775   Dali::Actor arg2 ;
71776   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
71777   Dali::Actor *argp2 ;
71778   bool result;
71779
71780   arg1 = (Dali::Toolkit::TableView *)jarg1;
71781   argp2 = (Dali::Actor *)jarg2;
71782   if (!argp2) {
71783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71784     return 0;
71785   }
71786   arg2 = *argp2;
71787   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
71788   if (!arg3) {
71789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
71790     return 0;
71791   }
71792   {
71793     try {
71794       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
71795     } catch (std::out_of_range& e) {
71796       {
71797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71798       };
71799     } catch (std::exception& e) {
71800       {
71801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71802       };
71803     } catch (...) {
71804       {
71805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71806       };
71807     }
71808   }
71809   jresult = result;
71810   return jresult;
71811 }
71812
71813
71814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
71815   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71816   unsigned int arg2 ;
71817
71818   arg1 = (Dali::Toolkit::TableView *)jarg1;
71819   arg2 = (unsigned int)jarg2;
71820   {
71821     try {
71822       (arg1)->InsertRow(arg2);
71823     } catch (std::out_of_range& e) {
71824       {
71825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71826       };
71827     } catch (std::exception& e) {
71828       {
71829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71830       };
71831     } catch (...) {
71832       {
71833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71834       };
71835     }
71836   }
71837 }
71838
71839
71840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
71841   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71842   unsigned int arg2 ;
71843
71844   arg1 = (Dali::Toolkit::TableView *)jarg1;
71845   arg2 = (unsigned int)jarg2;
71846   {
71847     try {
71848       (arg1)->DeleteRow(arg2);
71849     } catch (std::out_of_range& e) {
71850       {
71851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71852       };
71853     } catch (std::exception& e) {
71854       {
71855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71856       };
71857     } catch (...) {
71858       {
71859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71860       };
71861     }
71862   }
71863 }
71864
71865
71866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
71867   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71868   unsigned int arg2 ;
71869   std::vector< Dali::Actor > *arg3 = 0 ;
71870
71871   arg1 = (Dali::Toolkit::TableView *)jarg1;
71872   arg2 = (unsigned int)jarg2;
71873   arg3 = (std::vector< Dali::Actor > *)jarg3;
71874   if (!arg3) {
71875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
71876     return ;
71877   }
71878   {
71879     try {
71880       (arg1)->DeleteRow(arg2,*arg3);
71881     } catch (std::out_of_range& e) {
71882       {
71883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71884       };
71885     } catch (std::exception& e) {
71886       {
71887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71888       };
71889     } catch (...) {
71890       {
71891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71892       };
71893     }
71894   }
71895 }
71896
71897
71898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
71899   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71900   unsigned int arg2 ;
71901
71902   arg1 = (Dali::Toolkit::TableView *)jarg1;
71903   arg2 = (unsigned int)jarg2;
71904   {
71905     try {
71906       (arg1)->InsertColumn(arg2);
71907     } catch (std::out_of_range& e) {
71908       {
71909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71910       };
71911     } catch (std::exception& e) {
71912       {
71913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71914       };
71915     } catch (...) {
71916       {
71917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71918       };
71919     }
71920   }
71921 }
71922
71923
71924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
71925   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71926   unsigned int arg2 ;
71927
71928   arg1 = (Dali::Toolkit::TableView *)jarg1;
71929   arg2 = (unsigned int)jarg2;
71930   {
71931     try {
71932       (arg1)->DeleteColumn(arg2);
71933     } catch (std::out_of_range& e) {
71934       {
71935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71936       };
71937     } catch (std::exception& e) {
71938       {
71939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71940       };
71941     } catch (...) {
71942       {
71943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71944       };
71945     }
71946   }
71947 }
71948
71949
71950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
71951   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71952   unsigned int arg2 ;
71953   std::vector< Dali::Actor > *arg3 = 0 ;
71954
71955   arg1 = (Dali::Toolkit::TableView *)jarg1;
71956   arg2 = (unsigned int)jarg2;
71957   arg3 = (std::vector< Dali::Actor > *)jarg3;
71958   if (!arg3) {
71959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
71960     return ;
71961   }
71962   {
71963     try {
71964       (arg1)->DeleteColumn(arg2,*arg3);
71965     } catch (std::out_of_range& e) {
71966       {
71967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71968       };
71969     } catch (std::exception& e) {
71970       {
71971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71972       };
71973     } catch (...) {
71974       {
71975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71976       };
71977     }
71978   }
71979 }
71980
71981
71982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
71983   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71984   unsigned int arg2 ;
71985   unsigned int arg3 ;
71986
71987   arg1 = (Dali::Toolkit::TableView *)jarg1;
71988   arg2 = (unsigned int)jarg2;
71989   arg3 = (unsigned int)jarg3;
71990   {
71991     try {
71992       (arg1)->Resize(arg2,arg3);
71993     } catch (std::out_of_range& e) {
71994       {
71995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71996       };
71997     } catch (std::exception& e) {
71998       {
71999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72000       };
72001     } catch (...) {
72002       {
72003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72004       };
72005     }
72006   }
72007 }
72008
72009
72010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
72011   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72012   unsigned int arg2 ;
72013   unsigned int arg3 ;
72014   std::vector< Dali::Actor > *arg4 = 0 ;
72015
72016   arg1 = (Dali::Toolkit::TableView *)jarg1;
72017   arg2 = (unsigned int)jarg2;
72018   arg3 = (unsigned int)jarg3;
72019   arg4 = (std::vector< Dali::Actor > *)jarg4;
72020   if (!arg4) {
72021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
72022     return ;
72023   }
72024   {
72025     try {
72026       (arg1)->Resize(arg2,arg3,*arg4);
72027     } catch (std::out_of_range& e) {
72028       {
72029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72030       };
72031     } catch (std::exception& e) {
72032       {
72033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72034       };
72035     } catch (...) {
72036       {
72037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72038       };
72039     }
72040   }
72041 }
72042
72043
72044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
72045   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72046   Dali::Size arg2 ;
72047   Dali::Size *argp2 ;
72048
72049   arg1 = (Dali::Toolkit::TableView *)jarg1;
72050   argp2 = (Dali::Size *)jarg2;
72051   if (!argp2) {
72052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
72053     return ;
72054   }
72055   arg2 = *argp2;
72056   {
72057     try {
72058       (arg1)->SetCellPadding(arg2);
72059     } catch (std::out_of_range& e) {
72060       {
72061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72062       };
72063     } catch (std::exception& e) {
72064       {
72065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72066       };
72067     } catch (...) {
72068       {
72069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72070       };
72071     }
72072   }
72073 }
72074
72075
72076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
72077   void * jresult ;
72078   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72079   Dali::Size result;
72080
72081   arg1 = (Dali::Toolkit::TableView *)jarg1;
72082   {
72083     try {
72084       result = (arg1)->GetCellPadding();
72085     } catch (std::out_of_range& e) {
72086       {
72087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72088       };
72089     } catch (std::exception& e) {
72090       {
72091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72092       };
72093     } catch (...) {
72094       {
72095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72096       };
72097     }
72098   }
72099   jresult = new Dali::Size((const Dali::Size &)result);
72100   return jresult;
72101 }
72102
72103
72104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
72105   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72106   unsigned int arg2 ;
72107
72108   arg1 = (Dali::Toolkit::TableView *)jarg1;
72109   arg2 = (unsigned int)jarg2;
72110   {
72111     try {
72112       (arg1)->SetFitHeight(arg2);
72113     } catch (std::out_of_range& e) {
72114       {
72115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72116       };
72117     } catch (std::exception& e) {
72118       {
72119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72120       };
72121     } catch (...) {
72122       {
72123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72124       };
72125     }
72126   }
72127 }
72128
72129
72130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
72131   unsigned int jresult ;
72132   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72133   unsigned int arg2 ;
72134   bool result;
72135
72136   arg1 = (Dali::Toolkit::TableView *)jarg1;
72137   arg2 = (unsigned int)jarg2;
72138   {
72139     try {
72140       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
72141     } catch (std::out_of_range& e) {
72142       {
72143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72144       };
72145     } catch (std::exception& e) {
72146       {
72147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72148       };
72149     } catch (...) {
72150       {
72151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72152       };
72153     }
72154   }
72155   jresult = result;
72156   return jresult;
72157 }
72158
72159
72160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
72161   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72162   unsigned int arg2 ;
72163
72164   arg1 = (Dali::Toolkit::TableView *)jarg1;
72165   arg2 = (unsigned int)jarg2;
72166   {
72167     try {
72168       (arg1)->SetFitWidth(arg2);
72169     } catch (std::out_of_range& e) {
72170       {
72171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72172       };
72173     } catch (std::exception& e) {
72174       {
72175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72176       };
72177     } catch (...) {
72178       {
72179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72180       };
72181     }
72182   }
72183 }
72184
72185
72186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
72187   unsigned int jresult ;
72188   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72189   unsigned int arg2 ;
72190   bool result;
72191
72192   arg1 = (Dali::Toolkit::TableView *)jarg1;
72193   arg2 = (unsigned int)jarg2;
72194   {
72195     try {
72196       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
72197     } catch (std::out_of_range& e) {
72198       {
72199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72200       };
72201     } catch (std::exception& e) {
72202       {
72203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72204       };
72205     } catch (...) {
72206       {
72207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72208       };
72209     }
72210   }
72211   jresult = result;
72212   return jresult;
72213 }
72214
72215
72216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
72217   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72218   unsigned int arg2 ;
72219   float arg3 ;
72220
72221   arg1 = (Dali::Toolkit::TableView *)jarg1;
72222   arg2 = (unsigned int)jarg2;
72223   arg3 = (float)jarg3;
72224   {
72225     try {
72226       (arg1)->SetFixedHeight(arg2,arg3);
72227     } catch (std::out_of_range& e) {
72228       {
72229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72230       };
72231     } catch (std::exception& e) {
72232       {
72233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72234       };
72235     } catch (...) {
72236       {
72237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72238       };
72239     }
72240   }
72241 }
72242
72243
72244 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
72245   float jresult ;
72246   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72247   unsigned int arg2 ;
72248   float result;
72249
72250   arg1 = (Dali::Toolkit::TableView *)jarg1;
72251   arg2 = (unsigned int)jarg2;
72252   {
72253     try {
72254       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
72255     } catch (std::out_of_range& e) {
72256       {
72257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72258       };
72259     } catch (std::exception& e) {
72260       {
72261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72262       };
72263     } catch (...) {
72264       {
72265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72266       };
72267     }
72268   }
72269   jresult = result;
72270   return jresult;
72271 }
72272
72273
72274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
72275   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72276   unsigned int arg2 ;
72277   float arg3 ;
72278
72279   arg1 = (Dali::Toolkit::TableView *)jarg1;
72280   arg2 = (unsigned int)jarg2;
72281   arg3 = (float)jarg3;
72282   {
72283     try {
72284       (arg1)->SetRelativeHeight(arg2,arg3);
72285     } catch (std::out_of_range& e) {
72286       {
72287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72288       };
72289     } catch (std::exception& e) {
72290       {
72291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72292       };
72293     } catch (...) {
72294       {
72295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72296       };
72297     }
72298   }
72299 }
72300
72301
72302 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
72303   float jresult ;
72304   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72305   unsigned int arg2 ;
72306   float result;
72307
72308   arg1 = (Dali::Toolkit::TableView *)jarg1;
72309   arg2 = (unsigned int)jarg2;
72310   {
72311     try {
72312       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
72313     } catch (std::out_of_range& e) {
72314       {
72315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72316       };
72317     } catch (std::exception& e) {
72318       {
72319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72320       };
72321     } catch (...) {
72322       {
72323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72324       };
72325     }
72326   }
72327   jresult = result;
72328   return jresult;
72329 }
72330
72331
72332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
72333   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72334   unsigned int arg2 ;
72335   float arg3 ;
72336
72337   arg1 = (Dali::Toolkit::TableView *)jarg1;
72338   arg2 = (unsigned int)jarg2;
72339   arg3 = (float)jarg3;
72340   {
72341     try {
72342       (arg1)->SetFixedWidth(arg2,arg3);
72343     } catch (std::out_of_range& e) {
72344       {
72345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72346       };
72347     } catch (std::exception& e) {
72348       {
72349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72350       };
72351     } catch (...) {
72352       {
72353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72354       };
72355     }
72356   }
72357 }
72358
72359
72360 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
72361   float jresult ;
72362   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72363   unsigned int arg2 ;
72364   float result;
72365
72366   arg1 = (Dali::Toolkit::TableView *)jarg1;
72367   arg2 = (unsigned int)jarg2;
72368   {
72369     try {
72370       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
72371     } catch (std::out_of_range& e) {
72372       {
72373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72374       };
72375     } catch (std::exception& e) {
72376       {
72377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72378       };
72379     } catch (...) {
72380       {
72381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72382       };
72383     }
72384   }
72385   jresult = result;
72386   return jresult;
72387 }
72388
72389
72390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
72391   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72392   unsigned int arg2 ;
72393   float arg3 ;
72394
72395   arg1 = (Dali::Toolkit::TableView *)jarg1;
72396   arg2 = (unsigned int)jarg2;
72397   arg3 = (float)jarg3;
72398   {
72399     try {
72400       (arg1)->SetRelativeWidth(arg2,arg3);
72401     } catch (std::out_of_range& e) {
72402       {
72403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72404       };
72405     } catch (std::exception& e) {
72406       {
72407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72408       };
72409     } catch (...) {
72410       {
72411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72412       };
72413     }
72414   }
72415 }
72416
72417
72418 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
72419   float jresult ;
72420   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72421   unsigned int arg2 ;
72422   float result;
72423
72424   arg1 = (Dali::Toolkit::TableView *)jarg1;
72425   arg2 = (unsigned int)jarg2;
72426   {
72427     try {
72428       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
72429     } catch (std::out_of_range& e) {
72430       {
72431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72432       };
72433     } catch (std::exception& e) {
72434       {
72435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72436       };
72437     } catch (...) {
72438       {
72439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72440       };
72441     }
72442   }
72443   jresult = result;
72444   return jresult;
72445 }
72446
72447
72448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
72449   unsigned int jresult ;
72450   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72451   unsigned int result;
72452
72453   arg1 = (Dali::Toolkit::TableView *)jarg1;
72454   {
72455     try {
72456       result = (unsigned int)(arg1)->GetRows();
72457     } catch (std::out_of_range& e) {
72458       {
72459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72460       };
72461     } catch (std::exception& e) {
72462       {
72463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72464       };
72465     } catch (...) {
72466       {
72467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72468       };
72469     }
72470   }
72471   jresult = result;
72472   return jresult;
72473 }
72474
72475
72476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
72477   unsigned int jresult ;
72478   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72479   unsigned int result;
72480
72481   arg1 = (Dali::Toolkit::TableView *)jarg1;
72482   {
72483     try {
72484       result = (unsigned int)(arg1)->GetColumns();
72485     } catch (std::out_of_range& e) {
72486       {
72487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72488       };
72489     } catch (std::exception& e) {
72490       {
72491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72492       };
72493     } catch (...) {
72494       {
72495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72496       };
72497     }
72498   }
72499   jresult = result;
72500   return jresult;
72501 }
72502
72503
72504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
72505   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72506   Dali::Toolkit::TableView::CellPosition arg2 ;
72507   Dali::HorizontalAlignment::Type arg3 ;
72508   Dali::VerticalAlignment::Type arg4 ;
72509   Dali::Toolkit::TableView::CellPosition *argp2 ;
72510
72511   arg1 = (Dali::Toolkit::TableView *)jarg1;
72512   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
72513   if (!argp2) {
72514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
72515     return ;
72516   }
72517   arg2 = *argp2;
72518   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
72519   arg4 = (Dali::VerticalAlignment::Type)jarg4;
72520   {
72521     try {
72522       (arg1)->SetCellAlignment(arg2,arg3,arg4);
72523     } catch (std::out_of_range& e) {
72524       {
72525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72526       };
72527     } catch (std::exception& e) {
72528       {
72529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72530       };
72531     } catch (...) {
72532       {
72533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72534       };
72535     }
72536   }
72537 }
72538
72539
72540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
72541   unsigned int jresult ;
72542   unsigned int result;
72543
72544   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
72545   jresult = result;
72546   return jresult;
72547 }
72548
72549
72550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
72551   int jresult ;
72552   int result;
72553
72554   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
72555   jresult = (int)result;
72556   return jresult;
72557 }
72558
72559
72560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
72561   int jresult ;
72562   int result;
72563
72564   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
72565   jresult = (int)result;
72566   return jresult;
72567 }
72568
72569
72570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
72571   int jresult ;
72572   int result;
72573
72574   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
72575   jresult = (int)result;
72576   return jresult;
72577 }
72578
72579
72580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
72581   int jresult ;
72582   int result;
72583
72584   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
72585   jresult = (int)result;
72586   return jresult;
72587 }
72588
72589
72590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
72591   int jresult ;
72592   int result;
72593
72594   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
72595   jresult = (int)result;
72596   return jresult;
72597 }
72598
72599
72600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
72601   int jresult ;
72602   int result;
72603
72604   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
72605   jresult = (int)result;
72606   return jresult;
72607 }
72608
72609
72610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
72611   int jresult ;
72612   int result;
72613
72614   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
72615   jresult = (int)result;
72616   return jresult;
72617 }
72618
72619
72620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
72621   int jresult ;
72622   int result;
72623
72624   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
72625   jresult = (int)result;
72626   return jresult;
72627 }
72628
72629
72630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
72631   int jresult ;
72632   int result;
72633
72634   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
72635   jresult = (int)result;
72636   return jresult;
72637 }
72638
72639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
72640   int jresult ;
72641   int result;
72642
72643   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
72644   jresult = (int)result;
72645   return jresult;
72646 }
72647
72648
72649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
72650   int jresult ;
72651   int result;
72652
72653   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
72654   jresult = (int)result;
72655   return jresult;
72656 }
72657
72658
72659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
72660   int jresult ;
72661   int result;
72662
72663   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
72664   jresult = (int)result;
72665   return jresult;
72666 }
72667
72668
72669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
72670   int jresult ;
72671   int result;
72672
72673   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
72674   jresult = (int)result;
72675   return jresult;
72676 }
72677
72678
72679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
72680   int jresult ;
72681   int result;
72682
72683   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
72684   jresult = (int)result;
72685   return jresult;
72686 }
72687
72688
72689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
72690   int jresult ;
72691   int result;
72692
72693   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
72694   jresult = (int)result;
72695   return jresult;
72696 }
72697
72698
72699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
72700   int jresult ;
72701   int result;
72702
72703   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
72704   jresult = (int)result;
72705   return jresult;
72706 }
72707
72708
72709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
72710   int jresult ;
72711   int result;
72712
72713   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
72714   jresult = (int)result;
72715   return jresult;
72716 }
72717
72718
72719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
72720   int jresult ;
72721   int result;
72722
72723   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
72724   jresult = (int)result;
72725   return jresult;
72726 }
72727
72728
72729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
72730   int jresult ;
72731   int result;
72732
72733   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
72734   jresult = (int)result;
72735   return jresult;
72736 }
72737
72738
72739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
72740   int jresult ;
72741   int result;
72742
72743   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
72744   jresult = (int)result;
72745   return jresult;
72746 }
72747
72748
72749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
72750   int jresult ;
72751   int result;
72752
72753   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
72754   jresult = (int)result;
72755   return jresult;
72756 }
72757
72758
72759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
72760   int jresult ;
72761   int result;
72762
72763   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
72764   jresult = (int)result;
72765   return jresult;
72766 }
72767
72768
72769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
72770   int jresult ;
72771   int result;
72772
72773   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
72774   jresult = (int)result;
72775   return jresult;
72776 }
72777
72778
72779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
72780   int jresult ;
72781   int result;
72782
72783   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
72784   jresult = (int)result;
72785   return jresult;
72786 }
72787
72788
72789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
72790   void * jresult ;
72791   Dali::Toolkit::TextLabel::Property *result = 0 ;
72792
72793   {
72794     try {
72795       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
72796     } catch (std::out_of_range& e) {
72797       {
72798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72799       };
72800     } catch (std::exception& e) {
72801       {
72802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72803       };
72804     } catch (...) {
72805       {
72806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72807       };
72808     }
72809   }
72810   jresult = (void *)result;
72811   return jresult;
72812 }
72813
72814
72815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
72816   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
72817
72818   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
72819   {
72820     try {
72821       delete arg1;
72822     } catch (std::out_of_range& e) {
72823       {
72824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72825       };
72826     } catch (std::exception& e) {
72827       {
72828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72829       };
72830     } catch (...) {
72831       {
72832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72833       };
72834     }
72835   }
72836 }
72837
72838
72839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
72840   void * jresult ;
72841   Dali::Toolkit::TextLabel result;
72842
72843   {
72844     try {
72845       result = Dali::Toolkit::TextLabel::New();
72846     } catch (std::out_of_range& e) {
72847       {
72848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72849       };
72850     } catch (std::exception& e) {
72851       {
72852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72853       };
72854     } catch (...) {
72855       {
72856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72857       };
72858     }
72859   }
72860   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
72861   return jresult;
72862 }
72863
72864
72865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
72866   void * jresult ;
72867   std::string *arg1 = 0 ;
72868   Dali::Toolkit::TextLabel result;
72869
72870   if (!jarg1) {
72871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72872     return 0;
72873   }
72874   std::string arg1_str(jarg1);
72875   arg1 = &arg1_str;
72876   {
72877     try {
72878       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
72879     } catch (std::out_of_range& e) {
72880       {
72881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72882       };
72883     } catch (std::exception& e) {
72884       {
72885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72886       };
72887     } catch (...) {
72888       {
72889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72890       };
72891     }
72892   }
72893   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
72894
72895   //argout typemap for const std::string&
72896
72897   return jresult;
72898 }
72899
72900
72901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
72902   void * jresult ;
72903   Dali::Toolkit::TextLabel *result = 0 ;
72904
72905   {
72906     try {
72907       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
72908     } catch (std::out_of_range& e) {
72909       {
72910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72911       };
72912     } catch (std::exception& e) {
72913       {
72914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72915       };
72916     } catch (...) {
72917       {
72918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72919       };
72920     }
72921   }
72922   jresult = (void *)result;
72923   return jresult;
72924 }
72925
72926
72927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
72928   void * jresult ;
72929   Dali::Toolkit::TextLabel *arg1 = 0 ;
72930   Dali::Toolkit::TextLabel *result = 0 ;
72931
72932   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
72933   if (!arg1) {
72934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
72935     return 0;
72936   }
72937   {
72938     try {
72939       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
72940     } catch (std::out_of_range& e) {
72941       {
72942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72943       };
72944     } catch (std::exception& e) {
72945       {
72946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72947       };
72948     } catch (...) {
72949       {
72950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72951       };
72952     }
72953   }
72954   jresult = (void *)result;
72955   return jresult;
72956 }
72957
72958
72959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
72960   void * jresult ;
72961   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
72962   Dali::Toolkit::TextLabel *arg2 = 0 ;
72963   Dali::Toolkit::TextLabel *result = 0 ;
72964
72965   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
72966   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
72967   if (!arg2) {
72968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
72969     return 0;
72970   }
72971   {
72972     try {
72973       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
72974     } catch (std::out_of_range& e) {
72975       {
72976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72977       };
72978     } catch (std::exception& e) {
72979       {
72980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72981       };
72982     } catch (...) {
72983       {
72984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72985       };
72986     }
72987   }
72988   jresult = (void *)result;
72989   return jresult;
72990 }
72991
72992
72993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
72994   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
72995
72996   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
72997   {
72998     try {
72999       delete arg1;
73000     } catch (std::out_of_range& e) {
73001       {
73002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73003       };
73004     } catch (std::exception& e) {
73005       {
73006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73007       };
73008     } catch (...) {
73009       {
73010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73011       };
73012     }
73013   }
73014 }
73015
73016
73017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
73018   void * jresult ;
73019   Dali::BaseHandle arg1 ;
73020   Dali::BaseHandle *argp1 ;
73021   Dali::Toolkit::TextLabel result;
73022
73023   argp1 = (Dali::BaseHandle *)jarg1;
73024   if (!argp1) {
73025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73026     return 0;
73027   }
73028   arg1 = *argp1;
73029   {
73030     try {
73031       result = Dali::Toolkit::TextLabel::DownCast(arg1);
73032     } catch (std::out_of_range& e) {
73033       {
73034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73035       };
73036     } catch (std::exception& e) {
73037       {
73038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73039       };
73040     } catch (...) {
73041       {
73042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73043       };
73044     }
73045   }
73046   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
73047   return jresult;
73048 }
73049
73050
73051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
73052   void * jresult ;
73053   Dali::Toolkit::AccessibilityManager *result = 0 ;
73054
73055   {
73056     try {
73057       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
73058     } catch (std::out_of_range& e) {
73059       {
73060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73061       };
73062     } catch (std::exception& e) {
73063       {
73064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73065       };
73066     } catch (...) {
73067       {
73068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73069       };
73070     }
73071   }
73072   jresult = (void *)result;
73073   return jresult;
73074 }
73075
73076
73077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
73078   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73079
73080   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73081   {
73082     try {
73083       delete arg1;
73084     } catch (std::out_of_range& e) {
73085       {
73086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73087       };
73088     } catch (std::exception& e) {
73089       {
73090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73091       };
73092     } catch (...) {
73093       {
73094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73095       };
73096     }
73097   }
73098 }
73099
73100
73101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
73102   void * jresult ;
73103   Dali::Toolkit::AccessibilityManager result;
73104
73105   {
73106     try {
73107       result = Dali::Toolkit::AccessibilityManager::Get();
73108     } catch (std::out_of_range& e) {
73109       {
73110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73111       };
73112     } catch (std::exception& e) {
73113       {
73114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73115       };
73116     } catch (...) {
73117       {
73118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73119       };
73120     }
73121   }
73122   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
73123   return jresult;
73124 }
73125
73126
73127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
73128   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73129   Dali::Actor arg2 ;
73130   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
73131   std::string *arg4 = 0 ;
73132   Dali::Actor *argp2 ;
73133
73134   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73135   argp2 = (Dali::Actor *)jarg2;
73136   if (!argp2) {
73137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73138     return ;
73139   }
73140   arg2 = *argp2;
73141   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
73142   if (!jarg4) {
73143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
73144     return ;
73145   }
73146   std::string arg4_str(jarg4);
73147   arg4 = &arg4_str;
73148   {
73149     try {
73150       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
73151     } catch (std::out_of_range& e) {
73152       {
73153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73154       };
73155     } catch (std::exception& e) {
73156       {
73157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73158       };
73159     } catch (...) {
73160       {
73161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73162       };
73163     }
73164   }
73165
73166   //argout typemap for const std::string&
73167
73168 }
73169
73170
73171 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
73172   char * jresult ;
73173   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73174   Dali::Actor arg2 ;
73175   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
73176   Dali::Actor *argp2 ;
73177   std::string result;
73178
73179   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73180   argp2 = (Dali::Actor *)jarg2;
73181   if (!argp2) {
73182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73183     return 0;
73184   }
73185   arg2 = *argp2;
73186   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
73187   {
73188     try {
73189       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
73190     } catch (std::out_of_range& e) {
73191       {
73192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73193       };
73194     } catch (std::exception& e) {
73195       {
73196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73197       };
73198     } catch (...) {
73199       {
73200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73201       };
73202     }
73203   }
73204   jresult = SWIG_csharp_string_callback((&result)->c_str());
73205   return jresult;
73206 }
73207
73208
73209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
73210   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73211   Dali::Actor arg2 ;
73212   unsigned int arg3 ;
73213   Dali::Actor *argp2 ;
73214
73215   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73216   argp2 = (Dali::Actor *)jarg2;
73217   if (!argp2) {
73218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73219     return ;
73220   }
73221   arg2 = *argp2;
73222   arg3 = (unsigned int)jarg3;
73223   {
73224     try {
73225       (arg1)->SetFocusOrder(arg2,arg3);
73226     } catch (std::out_of_range& e) {
73227       {
73228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73229       };
73230     } catch (std::exception& e) {
73231       {
73232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73233       };
73234     } catch (...) {
73235       {
73236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73237       };
73238     }
73239   }
73240 }
73241
73242
73243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
73244   unsigned int jresult ;
73245   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73246   Dali::Actor arg2 ;
73247   Dali::Actor *argp2 ;
73248   unsigned int result;
73249
73250   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73251   argp2 = (Dali::Actor *)jarg2;
73252   if (!argp2) {
73253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73254     return 0;
73255   }
73256   arg2 = *argp2;
73257   {
73258     try {
73259       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
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 = result;
73275   return jresult;
73276 }
73277
73278
73279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
73280   unsigned int jresult ;
73281   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73282   unsigned int result;
73283
73284   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73285   {
73286     try {
73287       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
73288     } catch (std::out_of_range& e) {
73289       {
73290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73291       };
73292     } catch (std::exception& e) {
73293       {
73294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73295       };
73296     } catch (...) {
73297       {
73298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73299       };
73300     }
73301   }
73302   jresult = result;
73303   return jresult;
73304 }
73305
73306
73307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
73308   void * jresult ;
73309   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73310   unsigned int arg2 ;
73311   Dali::Actor result;
73312
73313   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73314   arg2 = (unsigned int)jarg2;
73315   {
73316     try {
73317       result = (arg1)->GetActorByFocusOrder(arg2);
73318     } catch (std::out_of_range& e) {
73319       {
73320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73321       };
73322     } catch (std::exception& e) {
73323       {
73324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73325       };
73326     } catch (...) {
73327       {
73328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73329       };
73330     }
73331   }
73332   jresult = new Dali::Actor((const Dali::Actor &)result);
73333   return jresult;
73334 }
73335
73336
73337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
73338   unsigned int jresult ;
73339   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73340   Dali::Actor arg2 ;
73341   Dali::Actor *argp2 ;
73342   bool result;
73343
73344   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73345   argp2 = (Dali::Actor *)jarg2;
73346   if (!argp2) {
73347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73348     return 0;
73349   }
73350   arg2 = *argp2;
73351   {
73352     try {
73353       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
73354     } catch (std::out_of_range& e) {
73355       {
73356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73357       };
73358     } catch (std::exception& e) {
73359       {
73360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73361       };
73362     } catch (...) {
73363       {
73364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73365       };
73366     }
73367   }
73368   jresult = result;
73369   return jresult;
73370 }
73371
73372
73373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
73374   void * jresult ;
73375   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73376   Dali::Actor result;
73377
73378   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73379   {
73380     try {
73381       result = (arg1)->GetCurrentFocusActor();
73382     } catch (std::out_of_range& e) {
73383       {
73384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73385       };
73386     } catch (std::exception& e) {
73387       {
73388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73389       };
73390     } catch (...) {
73391       {
73392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73393       };
73394     }
73395   }
73396   jresult = new Dali::Actor((const Dali::Actor &)result);
73397   return jresult;
73398 }
73399
73400
73401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
73402   void * jresult ;
73403   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73404   Dali::Actor result;
73405
73406   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73407   {
73408     try {
73409       result = (arg1)->GetCurrentFocusGroup();
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::Actor((const Dali::Actor &)result);
73425   return jresult;
73426 }
73427
73428
73429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
73430   unsigned int jresult ;
73431   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73432   unsigned int result;
73433
73434   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73435   {
73436     try {
73437       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
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 = result;
73453   return jresult;
73454 }
73455
73456
73457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
73458   unsigned int jresult ;
73459   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73460   bool result;
73461
73462   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73463   {
73464     try {
73465       result = (bool)(arg1)->MoveFocusForward();
73466     } catch (std::out_of_range& e) {
73467       {
73468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73469       };
73470     } catch (std::exception& e) {
73471       {
73472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73473       };
73474     } catch (...) {
73475       {
73476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73477       };
73478     }
73479   }
73480   jresult = result;
73481   return jresult;
73482 }
73483
73484
73485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
73486   unsigned int jresult ;
73487   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73488   bool result;
73489
73490   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73491   {
73492     try {
73493       result = (bool)(arg1)->MoveFocusBackward();
73494     } catch (std::out_of_range& e) {
73495       {
73496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73497       };
73498     } catch (std::exception& e) {
73499       {
73500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73501       };
73502     } catch (...) {
73503       {
73504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73505       };
73506     }
73507   }
73508   jresult = result;
73509   return jresult;
73510 }
73511
73512
73513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
73514   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73515
73516   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73517   {
73518     try {
73519       (arg1)->ClearFocus();
73520     } catch (std::out_of_range& e) {
73521       {
73522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73523       };
73524     } catch (std::exception& e) {
73525       {
73526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73527       };
73528     } catch (...) {
73529       {
73530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73531       };
73532     }
73533   }
73534 }
73535
73536
73537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
73538   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73539
73540   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73541   {
73542     try {
73543       (arg1)->Reset();
73544     } catch (std::out_of_range& e) {
73545       {
73546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73547       };
73548     } catch (std::exception& e) {
73549       {
73550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73551       };
73552     } catch (...) {
73553       {
73554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73555       };
73556     }
73557   }
73558 }
73559
73560
73561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
73562   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73563   Dali::Actor arg2 ;
73564   bool arg3 ;
73565   Dali::Actor *argp2 ;
73566
73567   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73568   argp2 = (Dali::Actor *)jarg2;
73569   if (!argp2) {
73570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73571     return ;
73572   }
73573   arg2 = *argp2;
73574   arg3 = jarg3 ? true : false;
73575   {
73576     try {
73577       (arg1)->SetFocusGroup(arg2,arg3);
73578     } catch (std::out_of_range& e) {
73579       {
73580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73581       };
73582     } catch (std::exception& e) {
73583       {
73584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73585       };
73586     } catch (...) {
73587       {
73588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73589       };
73590     }
73591   }
73592 }
73593
73594
73595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
73596   unsigned int jresult ;
73597   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73598   Dali::Actor arg2 ;
73599   Dali::Actor *argp2 ;
73600   bool result;
73601
73602   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73603   argp2 = (Dali::Actor *)jarg2;
73604   if (!argp2) {
73605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73606     return 0;
73607   }
73608   arg2 = *argp2;
73609   {
73610     try {
73611       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
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_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
73632   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73633   bool arg2 ;
73634
73635   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73636   arg2 = jarg2 ? true : false;
73637   {
73638     try {
73639       (arg1)->SetGroupMode(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 unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
73658   unsigned int jresult ;
73659   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73660   bool result;
73661
73662   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73663   {
73664     try {
73665       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
73666     } catch (std::out_of_range& e) {
73667       {
73668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73669       };
73670     } catch (std::exception& e) {
73671       {
73672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73673       };
73674     } catch (...) {
73675       {
73676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73677       };
73678     }
73679   }
73680   jresult = result;
73681   return jresult;
73682 }
73683
73684
73685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
73686   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73687   bool arg2 ;
73688
73689   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73690   arg2 = jarg2 ? true : false;
73691   {
73692     try {
73693       (arg1)->SetWrapMode(arg2);
73694     } catch (std::out_of_range& e) {
73695       {
73696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73697       };
73698     } catch (std::exception& e) {
73699       {
73700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73701       };
73702     } catch (...) {
73703       {
73704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73705       };
73706     }
73707   }
73708 }
73709
73710
73711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
73712   unsigned int jresult ;
73713   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73714   bool result;
73715
73716   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73717   {
73718     try {
73719       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
73720     } catch (std::out_of_range& e) {
73721       {
73722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73723       };
73724     } catch (std::exception& e) {
73725       {
73726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73727       };
73728     } catch (...) {
73729       {
73730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73731       };
73732     }
73733   }
73734   jresult = result;
73735   return jresult;
73736 }
73737
73738
73739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
73740   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73741   Dali::Actor arg2 ;
73742   Dali::Actor *argp2 ;
73743
73744   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73745   argp2 = (Dali::Actor *)jarg2;
73746   if (!argp2) {
73747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73748     return ;
73749   }
73750   arg2 = *argp2;
73751   {
73752     try {
73753       (arg1)->SetFocusIndicatorActor(arg2);
73754     } catch (std::out_of_range& e) {
73755       {
73756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73757       };
73758     } catch (std::exception& e) {
73759       {
73760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73761       };
73762     } catch (...) {
73763       {
73764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73765       };
73766     }
73767   }
73768 }
73769
73770
73771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
73772   void * jresult ;
73773   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73774   Dali::Actor result;
73775
73776   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73777   {
73778     try {
73779       result = (arg1)->GetFocusIndicatorActor();
73780     } catch (std::out_of_range& e) {
73781       {
73782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73783       };
73784     } catch (std::exception& e) {
73785       {
73786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73787       };
73788     } catch (...) {
73789       {
73790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73791       };
73792     }
73793   }
73794   jresult = new Dali::Actor((const Dali::Actor &)result);
73795   return jresult;
73796 }
73797
73798
73799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
73800   void * jresult ;
73801   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73802   Dali::Actor arg2 ;
73803   Dali::Actor *argp2 ;
73804   Dali::Actor result;
73805
73806   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73807   argp2 = (Dali::Actor *)jarg2;
73808   if (!argp2) {
73809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73810     return 0;
73811   }
73812   arg2 = *argp2;
73813   {
73814     try {
73815       result = (arg1)->GetFocusGroup(arg2);
73816     } catch (std::out_of_range& e) {
73817       {
73818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73819       };
73820     } catch (std::exception& e) {
73821       {
73822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73823       };
73824     } catch (...) {
73825       {
73826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73827       };
73828     }
73829   }
73830   jresult = new Dali::Actor((const Dali::Actor &)result);
73831   return jresult;
73832 }
73833
73834
73835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
73836   void * jresult ;
73837   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73838   Dali::Vector2 result;
73839
73840   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73841   {
73842     try {
73843       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
73844     } catch (std::out_of_range& e) {
73845       {
73846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73847       };
73848     } catch (std::exception& e) {
73849       {
73850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73851       };
73852     } catch (...) {
73853       {
73854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73855       };
73856     }
73857   }
73858   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
73859   return jresult;
73860 }
73861
73862
73863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
73864   void * jresult ;
73865   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73866   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
73867
73868   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73869   {
73870     try {
73871       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
73872     } catch (std::out_of_range& e) {
73873       {
73874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73875       };
73876     } catch (std::exception& e) {
73877       {
73878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73879       };
73880     } catch (...) {
73881       {
73882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73883       };
73884     }
73885   }
73886   jresult = (void *)result;
73887   return jresult;
73888 }
73889
73890
73891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
73892   void * jresult ;
73893   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73894   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
73895
73896   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73897   {
73898     try {
73899       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
73900     } catch (std::out_of_range& e) {
73901       {
73902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73903       };
73904     } catch (std::exception& e) {
73905       {
73906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73907       };
73908     } catch (...) {
73909       {
73910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73911       };
73912     }
73913   }
73914   jresult = (void *)result;
73915   return jresult;
73916 }
73917
73918
73919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
73920   void * jresult ;
73921   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73922   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
73923
73924   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73925   {
73926     try {
73927       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
73928     } catch (std::out_of_range& e) {
73929       {
73930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73931       };
73932     } catch (std::exception& e) {
73933       {
73934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73935       };
73936     } catch (...) {
73937       {
73938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73939       };
73940     }
73941   }
73942   jresult = (void *)result;
73943   return jresult;
73944 }
73945
73946
73947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
73948   void * jresult ;
73949   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73950   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
73951
73952   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73953   {
73954     try {
73955       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
73956     } catch (std::out_of_range& e) {
73957       {
73958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73959       };
73960     } catch (std::exception& e) {
73961       {
73962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73963       };
73964     } catch (...) {
73965       {
73966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73967       };
73968     }
73969   }
73970   jresult = (void *)result;
73971   return jresult;
73972 }
73973
73974
73975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
73976   void * jresult ;
73977   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73978   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
73979
73980   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73981   {
73982     try {
73983       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
73984     } catch (std::out_of_range& e) {
73985       {
73986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73987       };
73988     } catch (std::exception& e) {
73989       {
73990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73991       };
73992     } catch (...) {
73993       {
73994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73995       };
73996     }
73997   }
73998   jresult = (void *)result;
73999   return jresult;
74000 }
74001
74002
74003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
74004   void * jresult ;
74005   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74006   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74007
74008   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74009   {
74010     try {
74011       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
74012     } catch (std::out_of_range& e) {
74013       {
74014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74015       };
74016     } catch (std::exception& e) {
74017       {
74018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74019       };
74020     } catch (...) {
74021       {
74022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74023       };
74024     }
74025   }
74026   jresult = (void *)result;
74027   return jresult;
74028 }
74029
74030
74031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
74032   void * jresult ;
74033   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74034   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74035
74036   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74037   {
74038     try {
74039       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
74040     } catch (std::out_of_range& e) {
74041       {
74042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74043       };
74044     } catch (std::exception& e) {
74045       {
74046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74047       };
74048     } catch (...) {
74049       {
74050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74051       };
74052     }
74053   }
74054   jresult = (void *)result;
74055   return jresult;
74056 }
74057
74058
74059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
74060   void * jresult ;
74061   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74062   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74063
74064   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74065   {
74066     try {
74067       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
74068     } catch (std::out_of_range& e) {
74069       {
74070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74071       };
74072     } catch (std::exception& e) {
74073       {
74074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74075       };
74076     } catch (...) {
74077       {
74078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74079       };
74080     }
74081   }
74082   jresult = (void *)result;
74083   return jresult;
74084 }
74085
74086
74087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
74088   void * jresult ;
74089   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74090   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74091
74092   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74093   {
74094     try {
74095       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
74096     } catch (std::out_of_range& e) {
74097       {
74098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74099       };
74100     } catch (std::exception& e) {
74101       {
74102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74103       };
74104     } catch (...) {
74105       {
74106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74107       };
74108     }
74109   }
74110   jresult = (void *)result;
74111   return jresult;
74112 }
74113
74114
74115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
74116   void * jresult ;
74117   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74118   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74119
74120   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74121   {
74122     try {
74123       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
74124     } catch (std::out_of_range& e) {
74125       {
74126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74127       };
74128     } catch (std::exception& e) {
74129       {
74130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74131       };
74132     } catch (...) {
74133       {
74134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74135       };
74136     }
74137   }
74138   jresult = (void *)result;
74139   return jresult;
74140 }
74141
74142
74143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
74144   void * jresult ;
74145   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74146   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74147
74148   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74149   {
74150     try {
74151       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
74152     } catch (std::out_of_range& e) {
74153       {
74154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74155       };
74156     } catch (std::exception& e) {
74157       {
74158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74159       };
74160     } catch (...) {
74161       {
74162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74163       };
74164     }
74165   }
74166   jresult = (void *)result;
74167   return jresult;
74168 }
74169
74170
74171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
74172   void * jresult ;
74173   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74174   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74175
74176   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74177   {
74178     try {
74179       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
74180     } catch (std::out_of_range& e) {
74181       {
74182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74183       };
74184     } catch (std::exception& e) {
74185       {
74186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74187       };
74188     } catch (...) {
74189       {
74190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74191       };
74192     }
74193   }
74194   jresult = (void *)result;
74195   return jresult;
74196 }
74197
74198
74199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
74200   void * jresult ;
74201   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74202   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74203
74204   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74205   {
74206     try {
74207       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
74208     } catch (std::out_of_range& e) {
74209       {
74210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74211       };
74212     } catch (std::exception& e) {
74213       {
74214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74215       };
74216     } catch (...) {
74217       {
74218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74219       };
74220     }
74221   }
74222   jresult = (void *)result;
74223   return jresult;
74224 }
74225
74226
74227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
74228   void * jresult ;
74229   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74230   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74231
74232   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74233   {
74234     try {
74235       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
74236     } catch (std::out_of_range& e) {
74237       {
74238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74239       };
74240     } catch (std::exception& e) {
74241       {
74242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74243       };
74244     } catch (...) {
74245       {
74246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74247       };
74248     }
74249   }
74250   jresult = (void *)result;
74251   return jresult;
74252 }
74253
74254
74255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
74256   void * jresult ;
74257   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74258   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74259
74260   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74261   {
74262     try {
74263       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
74264     } catch (std::out_of_range& e) {
74265       {
74266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74267       };
74268     } catch (std::exception& e) {
74269       {
74270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74271       };
74272     } catch (...) {
74273       {
74274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74275       };
74276     }
74277   }
74278   jresult = (void *)result;
74279   return jresult;
74280 }
74281
74282
74283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
74284   void * jresult ;
74285   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74286   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74287
74288   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74289   {
74290     try {
74291       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
74292     } catch (std::out_of_range& e) {
74293       {
74294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74295       };
74296     } catch (std::exception& e) {
74297       {
74298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74299       };
74300     } catch (...) {
74301       {
74302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74303       };
74304     }
74305   }
74306   jresult = (void *)result;
74307   return jresult;
74308 }
74309
74310
74311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
74312   void * jresult ;
74313   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74314   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74315
74316   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74317   {
74318     try {
74319       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
74320     } catch (std::out_of_range& e) {
74321       {
74322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74323       };
74324     } catch (std::exception& e) {
74325       {
74326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74327       };
74328     } catch (...) {
74329       {
74330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74331       };
74332     }
74333   }
74334   jresult = (void *)result;
74335   return jresult;
74336 }
74337
74338
74339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
74340   void * jresult ;
74341   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74342   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74343
74344   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74345   {
74346     try {
74347       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
74348     } catch (std::out_of_range& e) {
74349       {
74350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74351       };
74352     } catch (std::exception& e) {
74353       {
74354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74355       };
74356     } catch (...) {
74357       {
74358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74359       };
74360     }
74361   }
74362   jresult = (void *)result;
74363   return jresult;
74364 }
74365
74366
74367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
74368   void * jresult ;
74369   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74370   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74371
74372   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74373   {
74374     try {
74375       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
74376     } catch (std::out_of_range& e) {
74377       {
74378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74379       };
74380     } catch (std::exception& e) {
74381       {
74382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74383       };
74384     } catch (...) {
74385       {
74386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74387       };
74388     }
74389   }
74390   jresult = (void *)result;
74391   return jresult;
74392 }
74393
74394
74395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
74396   void * jresult ;
74397   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74398   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74399
74400   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74401   {
74402     try {
74403       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
74404     } catch (std::out_of_range& e) {
74405       {
74406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74407       };
74408     } catch (std::exception& e) {
74409       {
74410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74411       };
74412     } catch (...) {
74413       {
74414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74415       };
74416     }
74417   }
74418   jresult = (void *)result;
74419   return jresult;
74420 }
74421
74422
74423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
74424   void * jresult ;
74425   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74426   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74427
74428   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74429   {
74430     try {
74431       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
74432     } catch (std::out_of_range& e) {
74433       {
74434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74435       };
74436     } catch (std::exception& e) {
74437       {
74438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74439       };
74440     } catch (...) {
74441       {
74442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74443       };
74444     }
74445   }
74446   jresult = (void *)result;
74447   return jresult;
74448 }
74449
74450
74451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
74452   void * jresult ;
74453   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74454   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74455
74456   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74457   {
74458     try {
74459       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
74460     } catch (std::out_of_range& e) {
74461       {
74462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74463       };
74464     } catch (std::exception& e) {
74465       {
74466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74467       };
74468     } catch (...) {
74469       {
74470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74471       };
74472     }
74473   }
74474   jresult = (void *)result;
74475   return jresult;
74476 }
74477
74478
74479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
74480   void * jresult ;
74481   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74482   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74483
74484   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74485   {
74486     try {
74487       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
74488     } catch (std::out_of_range& e) {
74489       {
74490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74491       };
74492     } catch (std::exception& e) {
74493       {
74494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74495       };
74496     } catch (...) {
74497       {
74498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74499       };
74500     }
74501   }
74502   jresult = (void *)result;
74503   return jresult;
74504 }
74505
74506
74507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
74508   void * jresult ;
74509   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74510   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74511
74512   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74513   {
74514     try {
74515       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
74516     } catch (std::out_of_range& e) {
74517       {
74518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74519       };
74520     } catch (std::exception& e) {
74521       {
74522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74523       };
74524     } catch (...) {
74525       {
74526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74527       };
74528     }
74529   }
74530   jresult = (void *)result;
74531   return jresult;
74532 }
74533
74534
74535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
74536   void * jresult ;
74537   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74538   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74539
74540   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74541   {
74542     try {
74543       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
74544     } catch (std::out_of_range& e) {
74545       {
74546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74547       };
74548     } catch (std::exception& e) {
74549       {
74550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74551       };
74552     } catch (...) {
74553       {
74554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74555       };
74556     }
74557   }
74558   jresult = (void *)result;
74559   return jresult;
74560 }
74561
74562
74563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
74564   void * jresult ;
74565   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74566   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74567
74568   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74569   {
74570     try {
74571       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
74572     } catch (std::out_of_range& e) {
74573       {
74574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74575       };
74576     } catch (std::exception& e) {
74577       {
74578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74579       };
74580     } catch (...) {
74581       {
74582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74583       };
74584     }
74585   }
74586   jresult = (void *)result;
74587   return jresult;
74588 }
74589
74590
74591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
74592   void * jresult ;
74593   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74594   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74595
74596   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74597   {
74598     try {
74599       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
74600     } catch (std::out_of_range& e) {
74601       {
74602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74603       };
74604     } catch (std::exception& e) {
74605       {
74606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74607       };
74608     } catch (...) {
74609       {
74610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74611       };
74612     }
74613   }
74614   jresult = (void *)result;
74615   return jresult;
74616 }
74617
74618
74619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
74620   void * jresult ;
74621   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74622   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74623
74624   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74625   {
74626     try {
74627       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
74628     } catch (std::out_of_range& e) {
74629       {
74630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74631       };
74632     } catch (std::exception& e) {
74633       {
74634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74635       };
74636     } catch (...) {
74637       {
74638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74639       };
74640     }
74641   }
74642   jresult = (void *)result;
74643   return jresult;
74644 }
74645
74646
74647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
74648   void * jresult ;
74649   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74650   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74651
74652   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74653   {
74654     try {
74655       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
74656     } catch (std::out_of_range& e) {
74657       {
74658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74659       };
74660     } catch (std::exception& e) {
74661       {
74662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74663       };
74664     } catch (...) {
74665       {
74666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74667       };
74668     }
74669   }
74670   jresult = (void *)result;
74671   return jresult;
74672 }
74673
74674
74675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
74676   void * jresult ;
74677   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74678   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
74679
74680   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74681   {
74682     try {
74683       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
74684     } catch (std::out_of_range& e) {
74685       {
74686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74687       };
74688     } catch (std::exception& e) {
74689       {
74690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74691       };
74692     } catch (...) {
74693       {
74694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74695       };
74696     }
74697   }
74698   jresult = (void *)result;
74699   return jresult;
74700 }
74701
74702
74703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
74704   void * jresult ;
74705   Dali::Toolkit::StyleManager *result = 0 ;
74706
74707   {
74708     try {
74709       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
74710     } catch (std::out_of_range& e) {
74711       {
74712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74713       };
74714     } catch (std::exception& e) {
74715       {
74716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74717       };
74718     } catch (...) {
74719       {
74720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74721       };
74722     }
74723   }
74724   jresult = (void *)result;
74725   return jresult;
74726 }
74727
74728
74729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
74730   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74731
74732   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74733   {
74734     try {
74735       delete arg1;
74736     } catch (std::out_of_range& e) {
74737       {
74738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74739       };
74740     } catch (std::exception& e) {
74741       {
74742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74743       };
74744     } catch (...) {
74745       {
74746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74747       };
74748     }
74749   }
74750 }
74751
74752
74753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
74754   void * jresult ;
74755   Dali::Toolkit::StyleManager result;
74756
74757   {
74758     try {
74759       result = Dali::Toolkit::StyleManager::Get();
74760     } catch (std::out_of_range& e) {
74761       {
74762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74763       };
74764     } catch (std::exception& e) {
74765       {
74766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74767       };
74768     } catch (...) {
74769       {
74770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74771       };
74772     }
74773   }
74774   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
74775   return jresult;
74776 }
74777
74778
74779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
74780   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74781   std::string *arg2 = 0 ;
74782
74783   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74784   if (!jarg2) {
74785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74786     return ;
74787   }
74788   std::string arg2_str(jarg2);
74789   arg2 = &arg2_str;
74790   {
74791     try {
74792       (arg1)->ApplyTheme((std::string const &)*arg2);
74793     } catch (std::out_of_range& e) {
74794       {
74795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74796       };
74797     } catch (std::exception& e) {
74798       {
74799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74800       };
74801     } catch (...) {
74802       {
74803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74804       };
74805     }
74806   }
74807
74808   //argout typemap for const std::string&
74809
74810 }
74811
74812
74813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
74814   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74815
74816   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74817   {
74818     try {
74819       (arg1)->ApplyDefaultTheme();
74820     } catch (std::out_of_range& e) {
74821       {
74822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74823       };
74824     } catch (std::exception& e) {
74825       {
74826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74827       };
74828     } catch (...) {
74829       {
74830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74831       };
74832     }
74833   }
74834 }
74835
74836
74837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
74838   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74839   std::string *arg2 = 0 ;
74840   Dali::Property::Value *arg3 = 0 ;
74841
74842   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74843   if (!jarg2) {
74844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74845     return ;
74846   }
74847   std::string arg2_str(jarg2);
74848   arg2 = &arg2_str;
74849   arg3 = (Dali::Property::Value *)jarg3;
74850   if (!arg3) {
74851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
74852     return ;
74853   }
74854   {
74855     try {
74856       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
74857     } catch (std::out_of_range& e) {
74858       {
74859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74860       };
74861     } catch (std::exception& e) {
74862       {
74863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74864       };
74865     } catch (...) {
74866       {
74867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74868       };
74869     }
74870   }
74871
74872   //argout typemap for const std::string&
74873
74874 }
74875
74876
74877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
74878   unsigned int jresult ;
74879   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74880   std::string *arg2 = 0 ;
74881   Dali::Property::Value *arg3 = 0 ;
74882   bool result;
74883
74884   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74885   if (!jarg2) {
74886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74887     return 0;
74888   }
74889   std::string arg2_str(jarg2);
74890   arg2 = &arg2_str;
74891   arg3 = (Dali::Property::Value *)jarg3;
74892   if (!arg3) {
74893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
74894     return 0;
74895   }
74896   {
74897     try {
74898       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
74899     } catch (std::out_of_range& e) {
74900       {
74901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74902       };
74903     } catch (std::exception& e) {
74904       {
74905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74906       };
74907     } catch (...) {
74908       {
74909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74910       };
74911     }
74912   }
74913   jresult = result;
74914
74915   //argout typemap for const std::string&
74916
74917   return jresult;
74918 }
74919
74920
74921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
74922   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74923   Dali::Toolkit::Control arg2 ;
74924   std::string *arg3 = 0 ;
74925   std::string *arg4 = 0 ;
74926   Dali::Toolkit::Control *argp2 ;
74927
74928   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74929   argp2 = (Dali::Toolkit::Control *)jarg2;
74930   if (!argp2) {
74931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
74932     return ;
74933   }
74934   arg2 = *argp2;
74935   if (!jarg3) {
74936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74937     return ;
74938   }
74939   std::string arg3_str(jarg3);
74940   arg3 = &arg3_str;
74941   if (!jarg4) {
74942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74943     return ;
74944   }
74945   std::string arg4_str(jarg4);
74946   arg4 = &arg4_str;
74947   {
74948     try {
74949       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
74950     } catch (std::out_of_range& e) {
74951       {
74952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74953       };
74954     } catch (std::exception& e) {
74955       {
74956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74957       };
74958     } catch (...) {
74959       {
74960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74961       };
74962     }
74963   }
74964
74965   //argout typemap for const std::string&
74966
74967
74968   //argout typemap for const std::string&
74969
74970 }
74971
74972
74973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
74974   void * jresult ;
74975   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74976   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
74977
74978   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74979   {
74980     try {
74981       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
74982     } catch (std::out_of_range& e) {
74983       {
74984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74985       };
74986     } catch (std::exception& e) {
74987       {
74988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74989       };
74990     } catch (...) {
74991       {
74992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74993       };
74994     }
74995   }
74996   jresult = (void *)result;
74997   return jresult;
74998 }
74999
75000
75001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
75002   int jresult ;
75003   int result;
75004
75005   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
75006   jresult = (int)result;
75007   return jresult;
75008 }
75009
75010
75011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
75012   int jresult ;
75013   int result;
75014
75015   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
75016   jresult = (int)result;
75017   return jresult;
75018 }
75019
75020
75021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
75022   int jresult ;
75023   int result;
75024
75025   result = (int)Dali::Toolkit::Slider::Property::VALUE;
75026   jresult = (int)result;
75027   return jresult;
75028 }
75029
75030
75031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
75032   int jresult ;
75033   int result;
75034
75035   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
75036   jresult = (int)result;
75037   return jresult;
75038 }
75039
75040
75041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
75042   int jresult ;
75043   int result;
75044
75045   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
75046   jresult = (int)result;
75047   return jresult;
75048 }
75049
75050
75051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
75052   int jresult ;
75053   int result;
75054
75055   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
75056   jresult = (int)result;
75057   return jresult;
75058 }
75059
75060
75061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
75062   int jresult ;
75063   int result;
75064
75065   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
75066   jresult = (int)result;
75067   return jresult;
75068 }
75069
75070
75071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
75072   int jresult ;
75073   int result;
75074
75075   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
75076   jresult = (int)result;
75077   return jresult;
75078 }
75079
75080
75081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
75082   int jresult ;
75083   int result;
75084
75085   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
75086   jresult = (int)result;
75087   return jresult;
75088 }
75089
75090
75091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
75092   int jresult ;
75093   int result;
75094
75095   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
75096   jresult = (int)result;
75097   return jresult;
75098 }
75099
75100
75101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
75102   int jresult ;
75103   int result;
75104
75105   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
75106   jresult = (int)result;
75107   return jresult;
75108 }
75109
75110
75111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
75112   int jresult ;
75113   int result;
75114
75115   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
75116   jresult = (int)result;
75117   return jresult;
75118 }
75119
75120
75121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
75122   int jresult ;
75123   int result;
75124
75125   result = (int)Dali::Toolkit::Slider::Property::MARKS;
75126   jresult = (int)result;
75127   return jresult;
75128 }
75129
75130
75131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
75132   int jresult ;
75133   int result;
75134
75135   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
75136   jresult = (int)result;
75137   return jresult;
75138 }
75139
75140
75141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
75142   int jresult ;
75143   int result;
75144
75145   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
75146   jresult = (int)result;
75147   return jresult;
75148 }
75149
75150
75151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
75152   void * jresult ;
75153   Dali::Toolkit::Slider::Property *result = 0 ;
75154
75155   {
75156     try {
75157       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
75158     } catch (std::out_of_range& e) {
75159       {
75160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75161       };
75162     } catch (std::exception& e) {
75163       {
75164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75165       };
75166     } catch (...) {
75167       {
75168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75169       };
75170     }
75171   }
75172   jresult = (void *)result;
75173   return jresult;
75174 }
75175
75176
75177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
75178   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
75179
75180   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
75181   {
75182     try {
75183       delete arg1;
75184     } catch (std::out_of_range& e) {
75185       {
75186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75187       };
75188     } catch (std::exception& e) {
75189       {
75190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75191       };
75192     } catch (...) {
75193       {
75194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75195       };
75196     }
75197   }
75198 }
75199
75200
75201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
75202   void * jresult ;
75203   Dali::Toolkit::Slider result;
75204
75205   {
75206     try {
75207       result = Dali::Toolkit::Slider::New();
75208     } catch (std::out_of_range& e) {
75209       {
75210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75211       };
75212     } catch (std::exception& e) {
75213       {
75214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75215       };
75216     } catch (...) {
75217       {
75218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75219       };
75220     }
75221   }
75222   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
75223   return jresult;
75224 }
75225
75226
75227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
75228   void * jresult ;
75229   Dali::Toolkit::Slider *result = 0 ;
75230
75231   {
75232     try {
75233       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
75234     } catch (std::out_of_range& e) {
75235       {
75236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75237       };
75238     } catch (std::exception& e) {
75239       {
75240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75241       };
75242     } catch (...) {
75243       {
75244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75245       };
75246     }
75247   }
75248   jresult = (void *)result;
75249   return jresult;
75250 }
75251
75252
75253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
75254   void * jresult ;
75255   Dali::Toolkit::Slider *arg1 = 0 ;
75256   Dali::Toolkit::Slider *result = 0 ;
75257
75258   arg1 = (Dali::Toolkit::Slider *)jarg1;
75259   if (!arg1) {
75260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
75261     return 0;
75262   }
75263   {
75264     try {
75265       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
75266     } catch (std::out_of_range& e) {
75267       {
75268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75269       };
75270     } catch (std::exception& e) {
75271       {
75272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75273       };
75274     } catch (...) {
75275       {
75276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75277       };
75278     }
75279   }
75280   jresult = (void *)result;
75281   return jresult;
75282 }
75283
75284
75285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
75286   void * jresult ;
75287   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75288   Dali::Toolkit::Slider *arg2 = 0 ;
75289   Dali::Toolkit::Slider *result = 0 ;
75290
75291   arg1 = (Dali::Toolkit::Slider *)jarg1;
75292   arg2 = (Dali::Toolkit::Slider *)jarg2;
75293   if (!arg2) {
75294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
75295     return 0;
75296   }
75297   {
75298     try {
75299       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
75300     } catch (std::out_of_range& e) {
75301       {
75302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75303       };
75304     } catch (std::exception& e) {
75305       {
75306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75307       };
75308     } catch (...) {
75309       {
75310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75311       };
75312     }
75313   }
75314   jresult = (void *)result;
75315   return jresult;
75316 }
75317
75318
75319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
75320   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75321
75322   arg1 = (Dali::Toolkit::Slider *)jarg1;
75323   {
75324     try {
75325       delete arg1;
75326     } catch (std::out_of_range& e) {
75327       {
75328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75329       };
75330     } catch (std::exception& e) {
75331       {
75332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75333       };
75334     } catch (...) {
75335       {
75336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75337       };
75338     }
75339   }
75340 }
75341
75342
75343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
75344   void * jresult ;
75345   Dali::BaseHandle arg1 ;
75346   Dali::BaseHandle *argp1 ;
75347   Dali::Toolkit::Slider result;
75348
75349   argp1 = (Dali::BaseHandle *)jarg1;
75350   if (!argp1) {
75351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75352     return 0;
75353   }
75354   arg1 = *argp1;
75355   {
75356     try {
75357       result = Dali::Toolkit::Slider::DownCast(arg1);
75358     } catch (std::out_of_range& e) {
75359       {
75360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75361       };
75362     } catch (std::exception& e) {
75363       {
75364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75365       };
75366     } catch (...) {
75367       {
75368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75369       };
75370     }
75371   }
75372   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
75373   return jresult;
75374 }
75375
75376
75377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
75378   void * jresult ;
75379   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75380   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
75381
75382   arg1 = (Dali::Toolkit::Slider *)jarg1;
75383   {
75384     try {
75385       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
75386     } catch (std::out_of_range& e) {
75387       {
75388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75389       };
75390     } catch (std::exception& e) {
75391       {
75392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75393       };
75394     } catch (...) {
75395       {
75396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75397       };
75398     }
75399   }
75400   jresult = (void *)result;
75401   return jresult;
75402 }
75403
75404
75405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
75406   void * jresult ;
75407   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75408   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
75409
75410   arg1 = (Dali::Toolkit::Slider *)jarg1;
75411   {
75412     try {
75413       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
75414     } catch (std::out_of_range& e) {
75415       {
75416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75417       };
75418     } catch (std::exception& e) {
75419       {
75420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75421       };
75422     } catch (...) {
75423       {
75424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75425       };
75426     }
75427   }
75428   jresult = (void *)result;
75429   return jresult;
75430 }
75431
75432
75433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
75434   void * jresult ;
75435   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75436   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
75437
75438   arg1 = (Dali::Toolkit::Slider *)jarg1;
75439   {
75440     try {
75441       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
75442     } catch (std::out_of_range& e) {
75443       {
75444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75445       };
75446     } catch (std::exception& e) {
75447       {
75448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75449       };
75450     } catch (...) {
75451       {
75452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75453       };
75454     }
75455   }
75456   jresult = (void *)result;
75457   return jresult;
75458 }
75459
75460
75461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
75462   int jresult ;
75463   int result;
75464
75465   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
75466   jresult = (int)result;
75467   return jresult;
75468 }
75469
75470
75471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
75472   int jresult ;
75473   int result;
75474
75475   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
75476   jresult = (int)result;
75477   return jresult;
75478 }
75479
75480
75481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
75482   int jresult ;
75483   int result;
75484
75485   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
75486   jresult = (int)result;
75487   return jresult;
75488 }
75489
75490
75491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
75492   int jresult ;
75493   int result;
75494
75495   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
75496   jresult = (int)result;
75497   return jresult;
75498 }
75499
75500
75501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
75502   void * jresult ;
75503   Dali::Toolkit::VideoView::Property *result = 0 ;
75504
75505   {
75506     try {
75507       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
75508     } catch (std::out_of_range& e) {
75509       {
75510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75511       };
75512     } catch (std::exception& e) {
75513       {
75514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75515       };
75516     } catch (...) {
75517       {
75518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75519       };
75520     }
75521   }
75522   jresult = (void *)result;
75523   return jresult;
75524 }
75525
75526
75527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
75528   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
75529
75530   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
75531   {
75532     try {
75533       delete arg1;
75534     } catch (std::out_of_range& e) {
75535       {
75536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75537       };
75538     } catch (std::exception& e) {
75539       {
75540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75541       };
75542     } catch (...) {
75543       {
75544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75545       };
75546     }
75547   }
75548 }
75549
75550
75551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
75552   void * jresult ;
75553   Dali::Toolkit::VideoView result;
75554
75555   {
75556     try {
75557       result = Dali::Toolkit::VideoView::New();
75558     } catch (std::out_of_range& e) {
75559       {
75560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75561       };
75562     } catch (std::exception& e) {
75563       {
75564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75565       };
75566     } catch (...) {
75567       {
75568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75569       };
75570     }
75571   }
75572   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75573   return jresult;
75574 }
75575
75576
75577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
75578   void * jresult ;
75579   std::string *arg1 = 0 ;
75580   Dali::Toolkit::VideoView result;
75581
75582   if (!jarg1) {
75583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
75584     return 0;
75585   }
75586   std::string arg1_str(jarg1);
75587   arg1 = &arg1_str;
75588   {
75589     try {
75590       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
75591     } catch (std::out_of_range& e) {
75592       {
75593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75594       };
75595     } catch (std::exception& e) {
75596       {
75597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75598       };
75599     } catch (...) {
75600       {
75601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75602       };
75603     }
75604   }
75605   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75606
75607   //argout typemap for const std::string&
75608
75609   return jresult;
75610 }
75611
75612
75613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
75614   void * jresult ;
75615   Dali::Toolkit::VideoView *result = 0 ;
75616
75617   {
75618     try {
75619       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
75620     } catch (std::out_of_range& e) {
75621       {
75622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75623       };
75624     } catch (std::exception& e) {
75625       {
75626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75627       };
75628     } catch (...) {
75629       {
75630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75631       };
75632     }
75633   }
75634   jresult = (void *)result;
75635   return jresult;
75636 }
75637
75638
75639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
75640   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75641
75642   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75643   {
75644     try {
75645       delete arg1;
75646     } catch (std::out_of_range& e) {
75647       {
75648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75649       };
75650     } catch (std::exception& e) {
75651       {
75652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75653       };
75654     } catch (...) {
75655       {
75656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75657       };
75658     }
75659   }
75660 }
75661
75662
75663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
75664   void * jresult ;
75665   Dali::Toolkit::VideoView *arg1 = 0 ;
75666   Dali::Toolkit::VideoView *result = 0 ;
75667
75668   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75669   if (!arg1) {
75670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
75671     return 0;
75672   }
75673   {
75674     try {
75675       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
75676     } catch (std::out_of_range& e) {
75677       {
75678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75679       };
75680     } catch (std::exception& e) {
75681       {
75682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75683       };
75684     } catch (...) {
75685       {
75686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75687       };
75688     }
75689   }
75690   jresult = (void *)result;
75691   return jresult;
75692 }
75693
75694
75695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
75696   void * jresult ;
75697   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75698   Dali::Toolkit::VideoView *arg2 = 0 ;
75699   Dali::Toolkit::VideoView *result = 0 ;
75700
75701   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75702   arg2 = (Dali::Toolkit::VideoView *)jarg2;
75703   if (!arg2) {
75704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
75705     return 0;
75706   }
75707   {
75708     try {
75709       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
75710     } catch (std::out_of_range& e) {
75711       {
75712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75713       };
75714     } catch (std::exception& e) {
75715       {
75716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75717       };
75718     } catch (...) {
75719       {
75720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75721       };
75722     }
75723   }
75724   jresult = (void *)result;
75725   return jresult;
75726 }
75727
75728
75729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
75730   void * jresult ;
75731   Dali::BaseHandle arg1 ;
75732   Dali::BaseHandle *argp1 ;
75733   Dali::Toolkit::VideoView result;
75734
75735   argp1 = (Dali::BaseHandle *)jarg1;
75736   if (!argp1) {
75737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75738     return 0;
75739   }
75740   arg1 = *argp1;
75741   {
75742     try {
75743       result = Dali::Toolkit::VideoView::DownCast(arg1);
75744     } catch (std::out_of_range& e) {
75745       {
75746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75747       };
75748     } catch (std::exception& e) {
75749       {
75750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75751       };
75752     } catch (...) {
75753       {
75754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75755       };
75756     }
75757   }
75758   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75759   return jresult;
75760 }
75761
75762
75763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
75764   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75765
75766   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75767   {
75768     try {
75769       (arg1)->Play();
75770     } catch (std::out_of_range& e) {
75771       {
75772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75773       };
75774     } catch (std::exception& e) {
75775       {
75776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75777       };
75778     } catch (...) {
75779       {
75780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75781       };
75782     }
75783   }
75784 }
75785
75786
75787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
75788   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75789
75790   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75791   {
75792     try {
75793       (arg1)->Pause();
75794     } catch (std::out_of_range& e) {
75795       {
75796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75797       };
75798     } catch (std::exception& e) {
75799       {
75800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75801       };
75802     } catch (...) {
75803       {
75804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75805       };
75806     }
75807   }
75808 }
75809
75810
75811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
75812   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75813
75814   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75815   {
75816     try {
75817       (arg1)->Stop();
75818     } catch (std::out_of_range& e) {
75819       {
75820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75821       };
75822     } catch (std::exception& e) {
75823       {
75824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75825       };
75826     } catch (...) {
75827       {
75828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75829       };
75830     }
75831   }
75832 }
75833
75834
75835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
75836   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75837   int arg2 ;
75838
75839   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75840   arg2 = (int)jarg2;
75841   {
75842     try {
75843       (arg1)->Forward(arg2);
75844     } catch (std::out_of_range& e) {
75845       {
75846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75847       };
75848     } catch (std::exception& e) {
75849       {
75850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75851       };
75852     } catch (...) {
75853       {
75854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75855       };
75856     }
75857   }
75858 }
75859
75860
75861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
75862   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75863   int arg2 ;
75864
75865   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75866   arg2 = (int)jarg2;
75867   {
75868     try {
75869       (arg1)->Backward(arg2);
75870     } catch (std::out_of_range& e) {
75871       {
75872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75873       };
75874     } catch (std::exception& e) {
75875       {
75876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75877       };
75878     } catch (...) {
75879       {
75880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75881       };
75882     }
75883   }
75884 }
75885
75886
75887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
75888   void * jresult ;
75889   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75890   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
75891
75892   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75893   {
75894     try {
75895       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
75896     } catch (std::out_of_range& e) {
75897       {
75898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75899       };
75900     } catch (std::exception& e) {
75901       {
75902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75903       };
75904     } catch (...) {
75905       {
75906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75907       };
75908     }
75909   }
75910   jresult = (void *)result;
75911   return jresult;
75912 }
75913
75914
75915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
75916   int jresult ;
75917   int result;
75918
75919   result = (int)Dali::Toolkit::Popup::Property::TITLE;
75920   jresult = (int)result;
75921   return jresult;
75922 }
75923
75924
75925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
75926   int jresult ;
75927   int result;
75928
75929   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
75930   jresult = (int)result;
75931   return jresult;
75932 }
75933
75934
75935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
75936   int jresult ;
75937   int result;
75938
75939   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
75940   jresult = (int)result;
75941   return jresult;
75942 }
75943
75944
75945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
75946   int jresult ;
75947   int result;
75948
75949   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
75950   jresult = (int)result;
75951   return jresult;
75952 }
75953
75954
75955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
75956   int jresult ;
75957   int result;
75958
75959   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
75960   jresult = (int)result;
75961   return jresult;
75962 }
75963
75964
75965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
75966   int jresult ;
75967   int result;
75968
75969   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
75970   jresult = (int)result;
75971   return jresult;
75972 }
75973
75974
75975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
75976   int jresult ;
75977   int result;
75978
75979   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
75980   jresult = (int)result;
75981   return jresult;
75982 }
75983
75984
75985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
75986   int jresult ;
75987   int result;
75988
75989   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
75990   jresult = (int)result;
75991   return jresult;
75992 }
75993
75994
75995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
75996   int jresult ;
75997   int result;
75998
75999   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
76000   jresult = (int)result;
76001   return jresult;
76002 }
76003
76004
76005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
76006   int jresult ;
76007   int result;
76008
76009   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
76010   jresult = (int)result;
76011   return jresult;
76012 }
76013
76014
76015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
76016   int jresult ;
76017   int result;
76018
76019   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
76020   jresult = (int)result;
76021   return jresult;
76022 }
76023
76024
76025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
76026   int jresult ;
76027   int result;
76028
76029   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
76030   jresult = (int)result;
76031   return jresult;
76032 }
76033
76034
76035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
76036   int jresult ;
76037   int result;
76038
76039   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
76040   jresult = (int)result;
76041   return jresult;
76042 }
76043
76044
76045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
76046   int jresult ;
76047   int result;
76048
76049   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
76050   jresult = (int)result;
76051   return jresult;
76052 }
76053
76054
76055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
76056   int jresult ;
76057   int result;
76058
76059   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
76060   jresult = (int)result;
76061   return jresult;
76062 }
76063
76064
76065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
76066   int jresult ;
76067   int result;
76068
76069   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
76070   jresult = (int)result;
76071   return jresult;
76072 }
76073
76074
76075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
76076   int jresult ;
76077   int result;
76078
76079   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
76080   jresult = (int)result;
76081   return jresult;
76082 }
76083
76084
76085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
76086   int jresult ;
76087   int result;
76088
76089   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
76090   jresult = (int)result;
76091   return jresult;
76092 }
76093
76094
76095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
76096   int jresult ;
76097   int result;
76098
76099   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
76100   jresult = (int)result;
76101   return jresult;
76102 }
76103
76104
76105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
76106   int jresult ;
76107   int result;
76108
76109   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
76110   jresult = (int)result;
76111   return jresult;
76112 }
76113
76114
76115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
76116   int jresult ;
76117   int result;
76118
76119   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
76120   jresult = (int)result;
76121   return jresult;
76122 }
76123
76124
76125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
76126   void * jresult ;
76127   Dali::Toolkit::Popup::Property *result = 0 ;
76128
76129   {
76130     try {
76131       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
76132     } catch (std::out_of_range& e) {
76133       {
76134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76135       };
76136     } catch (std::exception& e) {
76137       {
76138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76139       };
76140     } catch (...) {
76141       {
76142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76143       };
76144     }
76145   }
76146   jresult = (void *)result;
76147   return jresult;
76148 }
76149
76150
76151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
76152   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
76153
76154   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
76155   {
76156     try {
76157       delete arg1;
76158     } catch (std::out_of_range& e) {
76159       {
76160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76161       };
76162     } catch (std::exception& e) {
76163       {
76164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76165       };
76166     } catch (...) {
76167       {
76168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76169       };
76170     }
76171   }
76172 }
76173
76174
76175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
76176   void * jresult ;
76177   Dali::Toolkit::Popup *result = 0 ;
76178
76179   {
76180     try {
76181       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
76182     } catch (std::out_of_range& e) {
76183       {
76184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76185       };
76186     } catch (std::exception& e) {
76187       {
76188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76189       };
76190     } catch (...) {
76191       {
76192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76193       };
76194     }
76195   }
76196   jresult = (void *)result;
76197   return jresult;
76198 }
76199
76200
76201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
76202   void * jresult ;
76203   Dali::Toolkit::Popup result;
76204
76205   {
76206     try {
76207       result = Dali::Toolkit::Popup::New();
76208     } catch (std::out_of_range& e) {
76209       {
76210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76211       };
76212     } catch (std::exception& e) {
76213       {
76214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76215       };
76216     } catch (...) {
76217       {
76218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76219       };
76220     }
76221   }
76222   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
76223   return jresult;
76224 }
76225
76226
76227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
76228   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76229
76230   arg1 = (Dali::Toolkit::Popup *)jarg1;
76231   {
76232     try {
76233       delete arg1;
76234     } catch (std::out_of_range& e) {
76235       {
76236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76237       };
76238     } catch (std::exception& e) {
76239       {
76240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76241       };
76242     } catch (...) {
76243       {
76244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76245       };
76246     }
76247   }
76248 }
76249
76250
76251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
76252   void * jresult ;
76253   Dali::Toolkit::Popup *arg1 = 0 ;
76254   Dali::Toolkit::Popup *result = 0 ;
76255
76256   arg1 = (Dali::Toolkit::Popup *)jarg1;
76257   if (!arg1) {
76258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
76259     return 0;
76260   }
76261   {
76262     try {
76263       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
76264     } catch (std::out_of_range& e) {
76265       {
76266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76267       };
76268     } catch (std::exception& e) {
76269       {
76270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76271       };
76272     } catch (...) {
76273       {
76274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76275       };
76276     }
76277   }
76278   jresult = (void *)result;
76279   return jresult;
76280 }
76281
76282
76283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
76284   void * jresult ;
76285   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76286   Dali::Toolkit::Popup *arg2 = 0 ;
76287   Dali::Toolkit::Popup *result = 0 ;
76288
76289   arg1 = (Dali::Toolkit::Popup *)jarg1;
76290   arg2 = (Dali::Toolkit::Popup *)jarg2;
76291   if (!arg2) {
76292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
76293     return 0;
76294   }
76295   {
76296     try {
76297       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
76298     } catch (std::out_of_range& e) {
76299       {
76300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76301       };
76302     } catch (std::exception& e) {
76303       {
76304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76305       };
76306     } catch (...) {
76307       {
76308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76309       };
76310     }
76311   }
76312   jresult = (void *)result;
76313   return jresult;
76314 }
76315
76316
76317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
76318   void * jresult ;
76319   Dali::BaseHandle arg1 ;
76320   Dali::BaseHandle *argp1 ;
76321   Dali::Toolkit::Popup result;
76322
76323   argp1 = (Dali::BaseHandle *)jarg1;
76324   if (!argp1) {
76325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76326     return 0;
76327   }
76328   arg1 = *argp1;
76329   {
76330     try {
76331       result = Dali::Toolkit::Popup::DownCast(arg1);
76332     } catch (std::out_of_range& e) {
76333       {
76334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76335       };
76336     } catch (std::exception& e) {
76337       {
76338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76339       };
76340     } catch (...) {
76341       {
76342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76343       };
76344     }
76345   }
76346   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
76347   return jresult;
76348 }
76349
76350
76351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
76352   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76353   Dali::Actor arg2 ;
76354   Dali::Actor *argp2 ;
76355
76356   arg1 = (Dali::Toolkit::Popup *)jarg1;
76357   argp2 = (Dali::Actor *)jarg2;
76358   if (!argp2) {
76359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76360     return ;
76361   }
76362   arg2 = *argp2;
76363   {
76364     try {
76365       (arg1)->SetTitle(arg2);
76366     } catch (std::out_of_range& e) {
76367       {
76368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76369       };
76370     } catch (std::exception& e) {
76371       {
76372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76373       };
76374     } catch (...) {
76375       {
76376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76377       };
76378     }
76379   }
76380 }
76381
76382
76383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
76384   void * jresult ;
76385   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76386   Dali::Actor result;
76387
76388   arg1 = (Dali::Toolkit::Popup *)jarg1;
76389   {
76390     try {
76391       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
76392     } catch (std::out_of_range& e) {
76393       {
76394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76395       };
76396     } catch (std::exception& e) {
76397       {
76398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76399       };
76400     } catch (...) {
76401       {
76402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76403       };
76404     }
76405   }
76406   jresult = new Dali::Actor((const Dali::Actor &)result);
76407   return jresult;
76408 }
76409
76410
76411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
76412   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76413   Dali::Actor arg2 ;
76414   Dali::Actor *argp2 ;
76415
76416   arg1 = (Dali::Toolkit::Popup *)jarg1;
76417   argp2 = (Dali::Actor *)jarg2;
76418   if (!argp2) {
76419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76420     return ;
76421   }
76422   arg2 = *argp2;
76423   {
76424     try {
76425       (arg1)->SetContent(arg2);
76426     } catch (std::out_of_range& e) {
76427       {
76428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76429       };
76430     } catch (std::exception& e) {
76431       {
76432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76433       };
76434     } catch (...) {
76435       {
76436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76437       };
76438     }
76439   }
76440 }
76441
76442
76443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
76444   void * jresult ;
76445   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76446   Dali::Actor result;
76447
76448   arg1 = (Dali::Toolkit::Popup *)jarg1;
76449   {
76450     try {
76451       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
76452     } catch (std::out_of_range& e) {
76453       {
76454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76455       };
76456     } catch (std::exception& e) {
76457       {
76458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76459       };
76460     } catch (...) {
76461       {
76462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76463       };
76464     }
76465   }
76466   jresult = new Dali::Actor((const Dali::Actor &)result);
76467   return jresult;
76468 }
76469
76470
76471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
76472   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76473   Dali::Actor arg2 ;
76474   Dali::Actor *argp2 ;
76475
76476   arg1 = (Dali::Toolkit::Popup *)jarg1;
76477   argp2 = (Dali::Actor *)jarg2;
76478   if (!argp2) {
76479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76480     return ;
76481   }
76482   arg2 = *argp2;
76483   {
76484     try {
76485       (arg1)->SetFooter(arg2);
76486     } catch (std::out_of_range& e) {
76487       {
76488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76489       };
76490     } catch (std::exception& e) {
76491       {
76492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76493       };
76494     } catch (...) {
76495       {
76496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76497       };
76498     }
76499   }
76500 }
76501
76502
76503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
76504   void * jresult ;
76505   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76506   Dali::Actor result;
76507
76508   arg1 = (Dali::Toolkit::Popup *)jarg1;
76509   {
76510     try {
76511       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
76512     } catch (std::out_of_range& e) {
76513       {
76514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76515       };
76516     } catch (std::exception& e) {
76517       {
76518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76519       };
76520     } catch (...) {
76521       {
76522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76523       };
76524     }
76525   }
76526   jresult = new Dali::Actor((const Dali::Actor &)result);
76527   return jresult;
76528 }
76529
76530
76531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
76532   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76533   Dali::Toolkit::Popup::DisplayState arg2 ;
76534
76535   arg1 = (Dali::Toolkit::Popup *)jarg1;
76536   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
76537   {
76538     try {
76539       (arg1)->SetDisplayState(arg2);
76540     } catch (std::out_of_range& e) {
76541       {
76542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76543       };
76544     } catch (std::exception& e) {
76545       {
76546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76547       };
76548     } catch (...) {
76549       {
76550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76551       };
76552     }
76553   }
76554 }
76555
76556
76557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
76558   int jresult ;
76559   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76560   Dali::Toolkit::Popup::DisplayState result;
76561
76562   arg1 = (Dali::Toolkit::Popup *)jarg1;
76563   {
76564     try {
76565       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
76566     } catch (std::out_of_range& e) {
76567       {
76568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76569       };
76570     } catch (std::exception& e) {
76571       {
76572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76573       };
76574     } catch (...) {
76575       {
76576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76577       };
76578     }
76579   }
76580   jresult = (int)result;
76581   return jresult;
76582 }
76583
76584
76585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
76586   void * jresult ;
76587   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76588   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
76589
76590   arg1 = (Dali::Toolkit::Popup *)jarg1;
76591   {
76592     try {
76593       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
76594     } catch (std::out_of_range& e) {
76595       {
76596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76597       };
76598     } catch (std::exception& e) {
76599       {
76600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76601       };
76602     } catch (...) {
76603       {
76604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76605       };
76606     }
76607   }
76608   jresult = (void *)result;
76609   return jresult;
76610 }
76611
76612
76613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
76614   void * jresult ;
76615   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76616   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76617
76618   arg1 = (Dali::Toolkit::Popup *)jarg1;
76619   {
76620     try {
76621       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
76622     } catch (std::out_of_range& e) {
76623       {
76624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76625       };
76626     } catch (std::exception& e) {
76627       {
76628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76629       };
76630     } catch (...) {
76631       {
76632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76633       };
76634     }
76635   }
76636   jresult = (void *)result;
76637   return jresult;
76638 }
76639
76640
76641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
76642   void * jresult ;
76643   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76644   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76645
76646   arg1 = (Dali::Toolkit::Popup *)jarg1;
76647   {
76648     try {
76649       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
76650     } catch (std::out_of_range& e) {
76651       {
76652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76653       };
76654     } catch (std::exception& e) {
76655       {
76656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76657       };
76658     } catch (...) {
76659       {
76660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76661       };
76662     }
76663   }
76664   jresult = (void *)result;
76665   return jresult;
76666 }
76667
76668
76669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
76670   void * jresult ;
76671   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76672   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76673
76674   arg1 = (Dali::Toolkit::Popup *)jarg1;
76675   {
76676     try {
76677       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
76678     } catch (std::out_of_range& e) {
76679       {
76680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76681       };
76682     } catch (std::exception& e) {
76683       {
76684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76685       };
76686     } catch (...) {
76687       {
76688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76689       };
76690     }
76691   }
76692   jresult = (void *)result;
76693   return jresult;
76694 }
76695
76696
76697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
76698   void * jresult ;
76699   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76700   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76701
76702   arg1 = (Dali::Toolkit::Popup *)jarg1;
76703   {
76704     try {
76705       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
76706     } catch (std::out_of_range& e) {
76707       {
76708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76709       };
76710     } catch (std::exception& e) {
76711       {
76712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76713       };
76714     } catch (...) {
76715       {
76716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76717       };
76718     }
76719   }
76720   jresult = (void *)result;
76721   return jresult;
76722 }
76723
76724
76725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
76726   int jresult ;
76727   int result;
76728
76729   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
76730   jresult = (int)result;
76731   return jresult;
76732 }
76733
76734
76735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
76736   int jresult ;
76737   int result;
76738
76739   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
76740   jresult = (int)result;
76741   return jresult;
76742 }
76743
76744
76745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
76746   int jresult ;
76747   int result;
76748
76749   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
76750   jresult = (int)result;
76751   return jresult;
76752 }
76753
76754
76755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
76756   int jresult ;
76757   int result;
76758
76759   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
76760   jresult = (int)result;
76761   return jresult;
76762 }
76763
76764
76765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
76766   int jresult ;
76767   int result;
76768
76769   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
76770   jresult = (int)result;
76771   return jresult;
76772 }
76773
76774
76775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
76776   int jresult ;
76777   int result;
76778
76779   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
76780   jresult = (int)result;
76781   return jresult;
76782 }
76783
76784
76785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
76786   int jresult ;
76787   int result;
76788
76789   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
76790   jresult = (int)result;
76791   return jresult;
76792 }
76793
76794
76795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
76796   int jresult ;
76797   int result;
76798
76799   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
76800   jresult = (int)result;
76801   return jresult;
76802 }
76803
76804
76805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
76806   int jresult ;
76807   int result;
76808
76809   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
76810   jresult = (int)result;
76811   return jresult;
76812 }
76813
76814
76815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
76816   void * jresult ;
76817   Dali::Toolkit::ProgressBar::Property *result = 0 ;
76818
76819   {
76820     try {
76821       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
76822     } catch (std::out_of_range& e) {
76823       {
76824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76825       };
76826     } catch (std::exception& e) {
76827       {
76828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76829       };
76830     } catch (...) {
76831       {
76832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76833       };
76834     }
76835   }
76836   jresult = (void *)result;
76837   return jresult;
76838 }
76839
76840
76841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
76842   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
76843
76844   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
76845   {
76846     try {
76847       delete arg1;
76848     } catch (std::out_of_range& e) {
76849       {
76850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76851       };
76852     } catch (std::exception& e) {
76853       {
76854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76855       };
76856     } catch (...) {
76857       {
76858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76859       };
76860     }
76861   }
76862 }
76863
76864
76865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
76866   void * jresult ;
76867   Dali::Toolkit::ProgressBar result;
76868
76869   {
76870     try {
76871       result = Dali::Toolkit::ProgressBar::New();
76872     } catch (std::out_of_range& e) {
76873       {
76874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76875       };
76876     } catch (std::exception& e) {
76877       {
76878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76879       };
76880     } catch (...) {
76881       {
76882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76883       };
76884     }
76885   }
76886   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
76887   return jresult;
76888 }
76889
76890
76891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
76892   void * jresult ;
76893   Dali::Toolkit::ProgressBar *result = 0 ;
76894
76895   {
76896     try {
76897       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
76898     } catch (std::out_of_range& e) {
76899       {
76900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76901       };
76902     } catch (std::exception& e) {
76903       {
76904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76905       };
76906     } catch (...) {
76907       {
76908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76909       };
76910     }
76911   }
76912   jresult = (void *)result;
76913   return jresult;
76914 }
76915
76916
76917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
76918   void * jresult ;
76919   Dali::Toolkit::ProgressBar *arg1 = 0 ;
76920   Dali::Toolkit::ProgressBar *result = 0 ;
76921
76922   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
76923   if (!arg1) {
76924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
76925     return 0;
76926   }
76927   {
76928     try {
76929       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
76930     } catch (std::out_of_range& e) {
76931       {
76932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76933       };
76934     } catch (std::exception& e) {
76935       {
76936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76937       };
76938     } catch (...) {
76939       {
76940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76941       };
76942     }
76943   }
76944   jresult = (void *)result;
76945   return jresult;
76946 }
76947
76948
76949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
76950   void * jresult ;
76951   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
76952   Dali::Toolkit::ProgressBar *arg2 = 0 ;
76953   Dali::Toolkit::ProgressBar *result = 0 ;
76954
76955   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
76956   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
76957   if (!arg2) {
76958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
76959     return 0;
76960   }
76961   {
76962     try {
76963       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
76964     } catch (std::out_of_range& e) {
76965       {
76966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76967       };
76968     } catch (std::exception& e) {
76969       {
76970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76971       };
76972     } catch (...) {
76973       {
76974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76975       };
76976     }
76977   }
76978   jresult = (void *)result;
76979   return jresult;
76980 }
76981
76982
76983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
76984   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
76985
76986   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
76987   {
76988     try {
76989       delete arg1;
76990     } catch (std::out_of_range& e) {
76991       {
76992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76993       };
76994     } catch (std::exception& e) {
76995       {
76996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76997       };
76998     } catch (...) {
76999       {
77000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77001       };
77002     }
77003   }
77004 }
77005
77006
77007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
77008   void * jresult ;
77009   Dali::BaseHandle arg1 ;
77010   Dali::BaseHandle *argp1 ;
77011   Dali::Toolkit::ProgressBar result;
77012
77013   argp1 = (Dali::BaseHandle *)jarg1;
77014   if (!argp1) {
77015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77016     return 0;
77017   }
77018   arg1 = *argp1;
77019   {
77020     try {
77021       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
77022     } catch (std::out_of_range& e) {
77023       {
77024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77025       };
77026     } catch (std::exception& e) {
77027       {
77028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77029       };
77030     } catch (...) {
77031       {
77032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77033       };
77034     }
77035   }
77036   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
77037   return jresult;
77038 }
77039
77040
77041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
77042   void * jresult ;
77043   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
77044   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
77045
77046   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
77047   {
77048     try {
77049       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
77050     } catch (std::out_of_range& e) {
77051       {
77052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77053       };
77054     } catch (std::exception& e) {
77055       {
77056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77057       };
77058     } catch (...) {
77059       {
77060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77061       };
77062     }
77063   }
77064   jresult = (void *)result;
77065   return jresult;
77066 }
77067
77068
77069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
77070   void * jresult ;
77071   Dali::Toolkit::GaussianBlurView *result = 0 ;
77072
77073   {
77074     try {
77075       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
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_new_GaussianBlurView__SWIG_1(void * jarg1) {
77096   void * jresult ;
77097   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
77098   Dali::Toolkit::GaussianBlurView *result = 0 ;
77099
77100   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77101   if (!arg1) {
77102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
77103     return 0;
77104   }
77105   {
77106     try {
77107       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
77108     } catch (std::out_of_range& e) {
77109       {
77110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77111       };
77112     } catch (std::exception& e) {
77113       {
77114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77115       };
77116     } catch (...) {
77117       {
77118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77119       };
77120     }
77121   }
77122   jresult = (void *)result;
77123   return jresult;
77124 }
77125
77126
77127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
77128   void * jresult ;
77129   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77130   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
77131   Dali::Toolkit::GaussianBlurView *result = 0 ;
77132
77133   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77134   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
77135   if (!arg2) {
77136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
77137     return 0;
77138   }
77139   {
77140     try {
77141       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
77142     } catch (std::out_of_range& e) {
77143       {
77144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77145       };
77146     } catch (std::exception& e) {
77147       {
77148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77149       };
77150     } catch (...) {
77151       {
77152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77153       };
77154     }
77155   }
77156   jresult = (void *)result;
77157   return jresult;
77158 }
77159
77160
77161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
77162   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77163
77164   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77165   {
77166     try {
77167       delete arg1;
77168     } catch (std::out_of_range& e) {
77169       {
77170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77171       };
77172     } catch (std::exception& e) {
77173       {
77174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77175       };
77176     } catch (...) {
77177       {
77178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77179       };
77180     }
77181   }
77182 }
77183
77184
77185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
77186   void * jresult ;
77187   Dali::BaseHandle arg1 ;
77188   Dali::BaseHandle *argp1 ;
77189   Dali::Toolkit::GaussianBlurView result;
77190
77191   argp1 = (Dali::BaseHandle *)jarg1;
77192   if (!argp1) {
77193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77194     return 0;
77195   }
77196   arg1 = *argp1;
77197   {
77198     try {
77199       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
77200     } catch (std::out_of_range& e) {
77201       {
77202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77203       };
77204     } catch (std::exception& e) {
77205       {
77206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77207       };
77208     } catch (...) {
77209       {
77210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77211       };
77212     }
77213   }
77214   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77215   return jresult;
77216 }
77217
77218
77219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
77220   void * jresult ;
77221   Dali::Toolkit::GaussianBlurView result;
77222
77223   {
77224     try {
77225       result = Dali::Toolkit::GaussianBlurView::New();
77226     } catch (std::out_of_range& e) {
77227       {
77228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77229       };
77230     } catch (std::exception& e) {
77231       {
77232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77233       };
77234     } catch (...) {
77235       {
77236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77237       };
77238     }
77239   }
77240   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77241   return jresult;
77242 }
77243
77244
77245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
77246   void * jresult ;
77247   unsigned int arg1 ;
77248   float arg2 ;
77249   Dali::Pixel::Format arg3 ;
77250   float arg4 ;
77251   float arg5 ;
77252   bool arg6 ;
77253   Dali::Toolkit::GaussianBlurView result;
77254
77255   arg1 = (unsigned int)jarg1;
77256   arg2 = (float)jarg2;
77257   arg3 = (Dali::Pixel::Format)jarg3;
77258   arg4 = (float)jarg4;
77259   arg5 = (float)jarg5;
77260   arg6 = jarg6 ? true : false;
77261   {
77262     try {
77263       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
77264     } catch (std::out_of_range& e) {
77265       {
77266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77267       };
77268     } catch (std::exception& e) {
77269       {
77270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77271       };
77272     } catch (...) {
77273       {
77274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77275       };
77276     }
77277   }
77278   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77279   return jresult;
77280 }
77281
77282
77283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
77284   void * jresult ;
77285   unsigned int arg1 ;
77286   float arg2 ;
77287   Dali::Pixel::Format arg3 ;
77288   float arg4 ;
77289   float arg5 ;
77290   Dali::Toolkit::GaussianBlurView result;
77291
77292   arg1 = (unsigned int)jarg1;
77293   arg2 = (float)jarg2;
77294   arg3 = (Dali::Pixel::Format)jarg3;
77295   arg4 = (float)jarg4;
77296   arg5 = (float)jarg5;
77297   {
77298     try {
77299       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
77300     } catch (std::out_of_range& e) {
77301       {
77302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77303       };
77304     } catch (std::exception& e) {
77305       {
77306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77307       };
77308     } catch (...) {
77309       {
77310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77311       };
77312     }
77313   }
77314   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77315   return jresult;
77316 }
77317
77318
77319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
77320   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77321   Dali::Actor arg2 ;
77322   Dali::Actor *argp2 ;
77323
77324   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77325   argp2 = (Dali::Actor *)jarg2;
77326   if (!argp2) {
77327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77328     return ;
77329   }
77330   arg2 = *argp2;
77331   {
77332     try {
77333       (arg1)->Add(arg2);
77334     } catch (std::out_of_range& e) {
77335       {
77336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77337       };
77338     } catch (std::exception& e) {
77339       {
77340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77341       };
77342     } catch (...) {
77343       {
77344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77345       };
77346     }
77347   }
77348 }
77349
77350
77351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
77352   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77353   Dali::Actor arg2 ;
77354   Dali::Actor *argp2 ;
77355
77356   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77357   argp2 = (Dali::Actor *)jarg2;
77358   if (!argp2) {
77359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77360     return ;
77361   }
77362   arg2 = *argp2;
77363   {
77364     try {
77365       (arg1)->Remove(arg2);
77366     } catch (std::out_of_range& e) {
77367       {
77368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77369       };
77370     } catch (std::exception& e) {
77371       {
77372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77373       };
77374     } catch (...) {
77375       {
77376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77377       };
77378     }
77379   }
77380 }
77381
77382
77383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
77384   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77385
77386   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77387   {
77388     try {
77389       (arg1)->Activate();
77390     } catch (std::out_of_range& e) {
77391       {
77392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77393       };
77394     } catch (std::exception& e) {
77395       {
77396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77397       };
77398     } catch (...) {
77399       {
77400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77401       };
77402     }
77403   }
77404 }
77405
77406
77407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
77408   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77409
77410   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77411   {
77412     try {
77413       (arg1)->ActivateOnce();
77414     } catch (std::out_of_range& e) {
77415       {
77416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77417       };
77418     } catch (std::exception& e) {
77419       {
77420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77421       };
77422     } catch (...) {
77423       {
77424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77425       };
77426     }
77427   }
77428 }
77429
77430
77431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
77432   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77433
77434   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77435   {
77436     try {
77437       (arg1)->Deactivate();
77438     } catch (std::out_of_range& e) {
77439       {
77440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77441       };
77442     } catch (std::exception& e) {
77443       {
77444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77445       };
77446     } catch (...) {
77447       {
77448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77449       };
77450     }
77451   }
77452 }
77453
77454
77455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
77456   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77457   Dali::Image arg2 ;
77458   Dali::FrameBufferImage arg3 ;
77459   Dali::Image *argp2 ;
77460   Dali::FrameBufferImage *argp3 ;
77461
77462   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77463   argp2 = (Dali::Image *)jarg2;
77464   if (!argp2) {
77465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
77466     return ;
77467   }
77468   arg2 = *argp2;
77469   argp3 = (Dali::FrameBufferImage *)jarg3;
77470   if (!argp3) {
77471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
77472     return ;
77473   }
77474   arg3 = *argp3;
77475   {
77476     try {
77477       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
77478     } catch (std::out_of_range& e) {
77479       {
77480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77481       };
77482     } catch (std::exception& e) {
77483       {
77484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77485       };
77486     } catch (...) {
77487       {
77488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77489       };
77490     }
77491   }
77492 }
77493
77494
77495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
77496   int jresult ;
77497   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77498   Dali::Property::Index result;
77499
77500   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77501   {
77502     try {
77503       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
77504     } catch (std::out_of_range& e) {
77505       {
77506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77507       };
77508     } catch (std::exception& e) {
77509       {
77510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77511       };
77512     } catch (...) {
77513       {
77514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77515       };
77516     }
77517   }
77518   jresult = result;
77519   return jresult;
77520 }
77521
77522
77523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
77524   void * jresult ;
77525   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77526   Dali::FrameBufferImage result;
77527
77528   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77529   {
77530     try {
77531       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
77532     } catch (std::out_of_range& e) {
77533       {
77534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77535       };
77536     } catch (std::exception& e) {
77537       {
77538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77539       };
77540     } catch (...) {
77541       {
77542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77543       };
77544     }
77545   }
77546   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
77547   return jresult;
77548 }
77549
77550
77551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
77552   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77553   Dali::Vector4 *arg2 = 0 ;
77554
77555   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77556   arg2 = (Dali::Vector4 *)jarg2;
77557   if (!arg2) {
77558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
77559     return ;
77560   }
77561   {
77562     try {
77563       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
77564     } catch (std::out_of_range& e) {
77565       {
77566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77567       };
77568     } catch (std::exception& e) {
77569       {
77570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77571       };
77572     } catch (...) {
77573       {
77574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77575       };
77576     }
77577   }
77578 }
77579
77580
77581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
77582   void * jresult ;
77583   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77584   Dali::Vector4 result;
77585
77586   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77587   {
77588     try {
77589       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
77590     } catch (std::out_of_range& e) {
77591       {
77592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77593       };
77594     } catch (std::exception& e) {
77595       {
77596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77597       };
77598     } catch (...) {
77599       {
77600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77601       };
77602     }
77603   }
77604   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
77605   return jresult;
77606 }
77607
77608
77609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
77610   void * jresult ;
77611   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77612   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
77613
77614   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77615   {
77616     try {
77617       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
77618     } catch (std::out_of_range& e) {
77619       {
77620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77621       };
77622     } catch (std::exception& e) {
77623       {
77624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77625       };
77626     } catch (...) {
77627       {
77628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77629       };
77630     }
77631   }
77632   jresult = (void *)result;
77633   return jresult;
77634 }
77635
77636
77637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
77638   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77639
77640   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77641   {
77642     try {
77643       delete arg1;
77644     } catch (std::out_of_range& e) {
77645       {
77646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77647       };
77648     } catch (std::exception& e) {
77649       {
77650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77651       };
77652     } catch (...) {
77653       {
77654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77655       };
77656     }
77657   }
77658 }
77659
77660
77661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
77662   unsigned int jresult ;
77663   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77664   unsigned int result;
77665
77666   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77667   {
77668     try {
77669       result = (unsigned int)(arg1)->GetNumberOfPages();
77670     } catch (std::out_of_range& e) {
77671       {
77672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77673       };
77674     } catch (std::exception& e) {
77675       {
77676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77677       };
77678     } catch (...) {
77679       {
77680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77681       };
77682     }
77683   }
77684   jresult = result;
77685   return jresult;
77686 }
77687
77688
77689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
77690   void * jresult ;
77691   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77692   unsigned int arg2 ;
77693   Dali::Texture result;
77694
77695   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77696   arg2 = (unsigned int)jarg2;
77697   {
77698     try {
77699       result = (arg1)->NewPage(arg2);
77700     } catch (std::out_of_range& e) {
77701       {
77702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77703       };
77704     } catch (std::exception& e) {
77705       {
77706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77707       };
77708     } catch (...) {
77709       {
77710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77711       };
77712     }
77713   }
77714   jresult = new Dali::Texture((const Dali::Texture &)result);
77715   return jresult;
77716 }
77717
77718
77719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
77720   int jresult ;
77721   int result;
77722
77723   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
77724   jresult = (int)result;
77725   return jresult;
77726 }
77727
77728
77729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
77730   int jresult ;
77731   int result;
77732
77733   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
77734   jresult = (int)result;
77735   return jresult;
77736 }
77737
77738
77739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
77740   int jresult ;
77741   int result;
77742
77743   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
77744   jresult = (int)result;
77745   return jresult;
77746 }
77747
77748
77749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
77750   void * jresult ;
77751   Dali::Toolkit::PageTurnView::Property *result = 0 ;
77752
77753   {
77754     try {
77755       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
77756     } catch (std::out_of_range& e) {
77757       {
77758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77759       };
77760     } catch (std::exception& e) {
77761       {
77762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77763       };
77764     } catch (...) {
77765       {
77766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77767       };
77768     }
77769   }
77770   jresult = (void *)result;
77771   return jresult;
77772 }
77773
77774
77775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
77776   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
77777
77778   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
77779   {
77780     try {
77781       delete arg1;
77782     } catch (std::out_of_range& e) {
77783       {
77784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77785       };
77786     } catch (std::exception& e) {
77787       {
77788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77789       };
77790     } catch (...) {
77791       {
77792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77793       };
77794     }
77795   }
77796 }
77797
77798
77799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
77800   void * jresult ;
77801   Dali::Toolkit::PageTurnView *result = 0 ;
77802
77803   {
77804     try {
77805       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
77806     } catch (std::out_of_range& e) {
77807       {
77808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77809       };
77810     } catch (std::exception& e) {
77811       {
77812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77813       };
77814     } catch (...) {
77815       {
77816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77817       };
77818     }
77819   }
77820   jresult = (void *)result;
77821   return jresult;
77822 }
77823
77824
77825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
77826   void * jresult ;
77827   Dali::Toolkit::PageTurnView *arg1 = 0 ;
77828   Dali::Toolkit::PageTurnView *result = 0 ;
77829
77830   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77831   if (!arg1) {
77832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
77833     return 0;
77834   }
77835   {
77836     try {
77837       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
77838     } catch (std::out_of_range& e) {
77839       {
77840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77841       };
77842     } catch (std::exception& e) {
77843       {
77844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77845       };
77846     } catch (...) {
77847       {
77848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77849       };
77850     }
77851   }
77852   jresult = (void *)result;
77853   return jresult;
77854 }
77855
77856
77857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
77858   void * jresult ;
77859   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77860   Dali::Toolkit::PageTurnView *arg2 = 0 ;
77861   Dali::Toolkit::PageTurnView *result = 0 ;
77862
77863   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77864   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
77865   if (!arg2) {
77866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
77867     return 0;
77868   }
77869   {
77870     try {
77871       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
77872     } catch (std::out_of_range& e) {
77873       {
77874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77875       };
77876     } catch (std::exception& e) {
77877       {
77878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77879       };
77880     } catch (...) {
77881       {
77882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77883       };
77884     }
77885   }
77886   jresult = (void *)result;
77887   return jresult;
77888 }
77889
77890
77891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
77892   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77893
77894   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77895   {
77896     try {
77897       delete arg1;
77898     } catch (std::out_of_range& e) {
77899       {
77900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77901       };
77902     } catch (std::exception& e) {
77903       {
77904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77905       };
77906     } catch (...) {
77907       {
77908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77909       };
77910     }
77911   }
77912 }
77913
77914
77915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
77916   void * jresult ;
77917   Dali::BaseHandle arg1 ;
77918   Dali::BaseHandle *argp1 ;
77919   Dali::Toolkit::PageTurnView result;
77920
77921   argp1 = (Dali::BaseHandle *)jarg1;
77922   if (!argp1) {
77923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77924     return 0;
77925   }
77926   arg1 = *argp1;
77927   {
77928     try {
77929       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
77930     } catch (std::out_of_range& e) {
77931       {
77932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77933       };
77934     } catch (std::exception& e) {
77935       {
77936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77937       };
77938     } catch (...) {
77939       {
77940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77941       };
77942     }
77943   }
77944   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
77945   return jresult;
77946 }
77947
77948
77949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
77950   void * jresult ;
77951   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77952   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
77953
77954   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77955   {
77956     try {
77957       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
77958     } catch (std::out_of_range& e) {
77959       {
77960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77961       };
77962     } catch (std::exception& e) {
77963       {
77964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77965       };
77966     } catch (...) {
77967       {
77968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77969       };
77970     }
77971   }
77972   jresult = (void *)result;
77973   return jresult;
77974 }
77975
77976
77977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
77978   void * jresult ;
77979   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77980   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
77981
77982   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77983   {
77984     try {
77985       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
77986     } catch (std::out_of_range& e) {
77987       {
77988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77989       };
77990     } catch (std::exception& e) {
77991       {
77992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77993       };
77994     } catch (...) {
77995       {
77996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77997       };
77998     }
77999   }
78000   jresult = (void *)result;
78001   return jresult;
78002 }
78003
78004
78005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
78006   void * jresult ;
78007   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
78008   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
78009
78010   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
78011   {
78012     try {
78013       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
78014     } catch (std::out_of_range& e) {
78015       {
78016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78017       };
78018     } catch (std::exception& e) {
78019       {
78020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78021       };
78022     } catch (...) {
78023       {
78024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78025       };
78026     }
78027   }
78028   jresult = (void *)result;
78029   return jresult;
78030 }
78031
78032
78033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
78034   void * jresult ;
78035   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
78036   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
78037
78038   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
78039   {
78040     try {
78041       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
78042     } catch (std::out_of_range& e) {
78043       {
78044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78045       };
78046     } catch (std::exception& e) {
78047       {
78048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78049       };
78050     } catch (...) {
78051       {
78052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78053       };
78054     }
78055   }
78056   jresult = (void *)result;
78057   return jresult;
78058 }
78059
78060
78061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
78062   void * jresult ;
78063   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78064
78065   {
78066     try {
78067       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
78068     } catch (std::out_of_range& e) {
78069       {
78070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78071       };
78072     } catch (std::exception& e) {
78073       {
78074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78075       };
78076     } catch (...) {
78077       {
78078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78079       };
78080     }
78081   }
78082   jresult = (void *)result;
78083   return jresult;
78084 }
78085
78086
78087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
78088   void * jresult ;
78089   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
78090   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78091
78092   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78093   if (!arg1) {
78094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
78095     return 0;
78096   }
78097   {
78098     try {
78099       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
78100     } catch (std::out_of_range& e) {
78101       {
78102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78103       };
78104     } catch (std::exception& e) {
78105       {
78106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78107       };
78108     } catch (...) {
78109       {
78110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78111       };
78112     }
78113   }
78114   jresult = (void *)result;
78115   return jresult;
78116 }
78117
78118
78119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
78120   void * jresult ;
78121   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
78122   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
78123   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78124
78125   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78126   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
78127   if (!arg2) {
78128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
78129     return 0;
78130   }
78131   {
78132     try {
78133       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
78134     } catch (std::out_of_range& e) {
78135       {
78136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78137       };
78138     } catch (std::exception& e) {
78139       {
78140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78141       };
78142     } catch (...) {
78143       {
78144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78145       };
78146     }
78147   }
78148   jresult = (void *)result;
78149   return jresult;
78150 }
78151
78152
78153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
78154   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
78155
78156   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78157   {
78158     try {
78159       delete arg1;
78160     } catch (std::out_of_range& e) {
78161       {
78162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78163       };
78164     } catch (std::exception& e) {
78165       {
78166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78167       };
78168     } catch (...) {
78169       {
78170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78171       };
78172     }
78173   }
78174 }
78175
78176
78177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
78178   void * jresult ;
78179   Dali::Toolkit::PageFactory *arg1 = 0 ;
78180   Dali::Vector2 *arg2 = 0 ;
78181   Dali::Toolkit::PageTurnLandscapeView result;
78182
78183   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
78184   if (!arg1) {
78185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
78186     return 0;
78187   }
78188   arg2 = (Dali::Vector2 *)jarg2;
78189   if (!arg2) {
78190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78191     return 0;
78192   }
78193   {
78194     try {
78195       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
78196     } catch (std::out_of_range& e) {
78197       {
78198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78199       };
78200     } catch (std::exception& e) {
78201       {
78202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78203       };
78204     } catch (...) {
78205       {
78206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78207       };
78208     }
78209   }
78210   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
78211   return jresult;
78212 }
78213
78214
78215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
78216   void * jresult ;
78217   Dali::BaseHandle arg1 ;
78218   Dali::BaseHandle *argp1 ;
78219   Dali::Toolkit::PageTurnLandscapeView result;
78220
78221   argp1 = (Dali::BaseHandle *)jarg1;
78222   if (!argp1) {
78223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78224     return 0;
78225   }
78226   arg1 = *argp1;
78227   {
78228     try {
78229       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
78230     } catch (std::out_of_range& e) {
78231       {
78232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78233       };
78234     } catch (std::exception& e) {
78235       {
78236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78237       };
78238     } catch (...) {
78239       {
78240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78241       };
78242     }
78243   }
78244   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
78245   return jresult;
78246 }
78247
78248
78249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
78250   void * jresult ;
78251   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78252
78253   {
78254     try {
78255       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
78256     } catch (std::out_of_range& e) {
78257       {
78258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78259       };
78260     } catch (std::exception& e) {
78261       {
78262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78263       };
78264     } catch (...) {
78265       {
78266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78267       };
78268     }
78269   }
78270   jresult = (void *)result;
78271   return jresult;
78272 }
78273
78274
78275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
78276   void * jresult ;
78277   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
78278   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78279
78280   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78281   if (!arg1) {
78282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
78283     return 0;
78284   }
78285   {
78286     try {
78287       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
78288     } catch (std::out_of_range& e) {
78289       {
78290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78291       };
78292     } catch (std::exception& e) {
78293       {
78294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78295       };
78296     } catch (...) {
78297       {
78298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78299       };
78300     }
78301   }
78302   jresult = (void *)result;
78303   return jresult;
78304 }
78305
78306
78307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
78308   void * jresult ;
78309   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
78310   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
78311   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78312
78313   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78314   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
78315   if (!arg2) {
78316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
78317     return 0;
78318   }
78319   {
78320     try {
78321       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
78322     } catch (std::out_of_range& e) {
78323       {
78324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78325       };
78326     } catch (std::exception& e) {
78327       {
78328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78329       };
78330     } catch (...) {
78331       {
78332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78333       };
78334     }
78335   }
78336   jresult = (void *)result;
78337   return jresult;
78338 }
78339
78340
78341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
78342   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
78343
78344   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78345   {
78346     try {
78347       delete arg1;
78348     } catch (std::out_of_range& e) {
78349       {
78350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78351       };
78352     } catch (std::exception& e) {
78353       {
78354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78355       };
78356     } catch (...) {
78357       {
78358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78359       };
78360     }
78361   }
78362 }
78363
78364
78365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
78366   void * jresult ;
78367   Dali::Toolkit::PageFactory *arg1 = 0 ;
78368   Dali::Vector2 *arg2 = 0 ;
78369   Dali::Toolkit::PageTurnPortraitView result;
78370
78371   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
78372   if (!arg1) {
78373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
78374     return 0;
78375   }
78376   arg2 = (Dali::Vector2 *)jarg2;
78377   if (!arg2) {
78378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78379     return 0;
78380   }
78381   {
78382     try {
78383       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
78384     } catch (std::out_of_range& e) {
78385       {
78386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78387       };
78388     } catch (std::exception& e) {
78389       {
78390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78391       };
78392     } catch (...) {
78393       {
78394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78395       };
78396     }
78397   }
78398   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
78399   return jresult;
78400 }
78401
78402
78403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
78404   void * jresult ;
78405   Dali::BaseHandle arg1 ;
78406   Dali::BaseHandle *argp1 ;
78407   Dali::Toolkit::PageTurnPortraitView result;
78408
78409   argp1 = (Dali::BaseHandle *)jarg1;
78410   if (!argp1) {
78411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78412     return 0;
78413   }
78414   arg1 = *argp1;
78415   {
78416     try {
78417       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
78418     } catch (std::out_of_range& e) {
78419       {
78420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78421       };
78422     } catch (std::exception& e) {
78423       {
78424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78425       };
78426     } catch (...) {
78427       {
78428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78429       };
78430     }
78431   }
78432   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
78433   return jresult;
78434 }
78435
78436
78437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
78438   int jresult ;
78439   int result;
78440
78441   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
78442   jresult = (int)result;
78443   return jresult;
78444 }
78445
78446
78447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
78448   int jresult ;
78449   int result;
78450
78451   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
78452   jresult = (int)result;
78453   return jresult;
78454 }
78455
78456
78457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
78458   int jresult ;
78459   int result;
78460
78461   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
78462   jresult = (int)result;
78463   return jresult;
78464 }
78465
78466
78467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
78468   void * jresult ;
78469   Dali::Toolkit::ToggleButton::Property *result = 0 ;
78470
78471   {
78472     try {
78473       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
78474     } catch (std::out_of_range& e) {
78475       {
78476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78477       };
78478     } catch (std::exception& e) {
78479       {
78480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78481       };
78482     } catch (...) {
78483       {
78484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78485       };
78486     }
78487   }
78488   jresult = (void *)result;
78489   return jresult;
78490 }
78491
78492
78493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
78494   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
78495
78496   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
78497   {
78498     try {
78499       delete arg1;
78500     } catch (std::out_of_range& e) {
78501       {
78502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78503       };
78504     } catch (std::exception& e) {
78505       {
78506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78507       };
78508     } catch (...) {
78509       {
78510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78511       };
78512     }
78513   }
78514 }
78515
78516
78517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
78518   void * jresult ;
78519   Dali::Toolkit::ToggleButton *result = 0 ;
78520
78521   {
78522     try {
78523       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
78524     } catch (std::out_of_range& e) {
78525       {
78526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78527       };
78528     } catch (std::exception& e) {
78529       {
78530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78531       };
78532     } catch (...) {
78533       {
78534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78535       };
78536     }
78537   }
78538   jresult = (void *)result;
78539   return jresult;
78540 }
78541
78542
78543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
78544   void * jresult ;
78545   Dali::Toolkit::ToggleButton *arg1 = 0 ;
78546   Dali::Toolkit::ToggleButton *result = 0 ;
78547
78548   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78549   if (!arg1) {
78550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
78551     return 0;
78552   }
78553   {
78554     try {
78555       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
78556     } catch (std::out_of_range& e) {
78557       {
78558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78559       };
78560     } catch (std::exception& e) {
78561       {
78562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78563       };
78564     } catch (...) {
78565       {
78566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78567       };
78568     }
78569   }
78570   jresult = (void *)result;
78571   return jresult;
78572 }
78573
78574
78575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
78576   void * jresult ;
78577   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
78578   Dali::Toolkit::ToggleButton *arg2 = 0 ;
78579   Dali::Toolkit::ToggleButton *result = 0 ;
78580
78581   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78582   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
78583   if (!arg2) {
78584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
78585     return 0;
78586   }
78587   {
78588     try {
78589       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
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_delete_ToggleButton(void * jarg1) {
78610   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
78611
78612   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78613   {
78614     try {
78615       delete arg1;
78616     } catch (std::out_of_range& e) {
78617       {
78618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78619       };
78620     } catch (std::exception& e) {
78621       {
78622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78623       };
78624     } catch (...) {
78625       {
78626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78627       };
78628     }
78629   }
78630 }
78631
78632
78633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
78634   void * jresult ;
78635   Dali::Toolkit::ToggleButton result;
78636
78637   {
78638     try {
78639       result = Dali::Toolkit::ToggleButton::New();
78640     } catch (std::out_of_range& e) {
78641       {
78642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78643       };
78644     } catch (std::exception& e) {
78645       {
78646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78647       };
78648     } catch (...) {
78649       {
78650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78651       };
78652     }
78653   }
78654   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
78655   return jresult;
78656 }
78657
78658
78659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
78660   void * jresult ;
78661   Dali::BaseHandle arg1 ;
78662   Dali::BaseHandle *argp1 ;
78663   Dali::Toolkit::ToggleButton result;
78664
78665   argp1 = (Dali::BaseHandle *)jarg1;
78666   if (!argp1) {
78667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78668     return 0;
78669   }
78670   arg1 = *argp1;
78671   {
78672     try {
78673       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
78674     } catch (std::out_of_range& e) {
78675       {
78676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78677       };
78678     } catch (std::exception& e) {
78679       {
78680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78681       };
78682     } catch (...) {
78683       {
78684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78685       };
78686     }
78687   }
78688   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
78689   return jresult;
78690 }
78691
78692
78693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
78694   void * jresult ;
78695   Dali::Toolkit::Visual::Base *result = 0 ;
78696
78697   {
78698     try {
78699       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
78700     } catch (std::out_of_range& e) {
78701       {
78702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78703       };
78704     } catch (std::exception& e) {
78705       {
78706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78707       };
78708     } catch (...) {
78709       {
78710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78711       };
78712     }
78713   }
78714   jresult = (void *)result;
78715   return jresult;
78716 }
78717
78718
78719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
78720   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78721
78722   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78723   {
78724     try {
78725       delete arg1;
78726     } catch (std::out_of_range& e) {
78727       {
78728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78729       };
78730     } catch (std::exception& e) {
78731       {
78732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78733       };
78734     } catch (...) {
78735       {
78736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78737       };
78738     }
78739   }
78740 }
78741
78742
78743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
78744   void * jresult ;
78745   Dali::Toolkit::Visual::Base *arg1 = 0 ;
78746   Dali::Toolkit::Visual::Base *result = 0 ;
78747
78748   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78749   if (!arg1) {
78750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
78751     return 0;
78752   }
78753   {
78754     try {
78755       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
78756     } catch (std::out_of_range& e) {
78757       {
78758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78759       };
78760     } catch (std::exception& e) {
78761       {
78762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78763       };
78764     } catch (...) {
78765       {
78766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78767       };
78768     }
78769   }
78770   jresult = (void *)result;
78771   return jresult;
78772 }
78773
78774
78775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
78776   void * jresult ;
78777   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78778   Dali::Toolkit::Visual::Base *arg2 = 0 ;
78779   Dali::Toolkit::Visual::Base *result = 0 ;
78780
78781   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78782   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
78783   if (!arg2) {
78784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
78785     return 0;
78786   }
78787   {
78788     try {
78789       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
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 = (void *)result;
78805   return jresult;
78806 }
78807
78808
78809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
78810   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78811   std::string *arg2 = 0 ;
78812
78813   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78814   if (!jarg2) {
78815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78816     return ;
78817   }
78818   std::string arg2_str(jarg2);
78819   arg2 = &arg2_str;
78820   {
78821     try {
78822       (arg1)->SetName((std::string const &)*arg2);
78823     } catch (std::out_of_range& e) {
78824       {
78825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78826       };
78827     } catch (std::exception& e) {
78828       {
78829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78830       };
78831     } catch (...) {
78832       {
78833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78834       };
78835     }
78836   }
78837
78838   //argout typemap for const std::string&
78839
78840 }
78841
78842
78843 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
78844   char * jresult ;
78845   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78846   std::string *result = 0 ;
78847
78848   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78849   {
78850     try {
78851       result = (std::string *) &(arg1)->GetName();
78852     } catch (std::out_of_range& e) {
78853       {
78854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78855       };
78856     } catch (std::exception& e) {
78857       {
78858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78859       };
78860     } catch (...) {
78861       {
78862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78863       };
78864     }
78865   }
78866   jresult = SWIG_csharp_string_callback(result->c_str());
78867   return jresult;
78868 }
78869
78870
78871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
78872   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78873   Dali::Property::Map *arg2 = 0 ;
78874   Dali::Size arg3 ;
78875   Dali::Size *argp3 ;
78876
78877   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78878   arg2 = (Dali::Property::Map *)jarg2;
78879   if (!arg2) {
78880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
78881     return ;
78882   }
78883   argp3 = (Dali::Size *)jarg3;
78884   if (!argp3) {
78885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
78886     return ;
78887   }
78888   arg3 = *argp3;
78889   {
78890     try {
78891       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
78892     } catch (std::out_of_range& e) {
78893       {
78894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78895       };
78896     } catch (std::exception& e) {
78897       {
78898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78899       };
78900     } catch (...) {
78901       {
78902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78903       };
78904     }
78905   }
78906 }
78907
78908
78909 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
78910   float jresult ;
78911   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78912   float arg2 ;
78913   float result;
78914
78915   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78916   arg2 = (float)jarg2;
78917   {
78918     try {
78919       result = (float)(arg1)->GetHeightForWidth(arg2);
78920     } catch (std::out_of_range& e) {
78921       {
78922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78923       };
78924     } catch (std::exception& e) {
78925       {
78926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78927       };
78928     } catch (...) {
78929       {
78930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78931       };
78932     }
78933   }
78934   jresult = result;
78935   return jresult;
78936 }
78937
78938
78939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
78940   float jresult ;
78941   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78942   float arg2 ;
78943   float result;
78944
78945   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78946   arg2 = (float)jarg2;
78947   {
78948     try {
78949       result = (float)(arg1)->GetWidthForHeight(arg2);
78950     } catch (std::out_of_range& e) {
78951       {
78952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78953       };
78954     } catch (std::exception& e) {
78955       {
78956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78957       };
78958     } catch (...) {
78959       {
78960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78961       };
78962     }
78963   }
78964   jresult = result;
78965   return jresult;
78966 }
78967
78968
78969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
78970   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78971   Dali::Vector2 *arg2 = 0 ;
78972
78973   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78974   arg2 = (Dali::Vector2 *)jarg2;
78975   if (!arg2) {
78976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
78977     return ;
78978   }
78979   {
78980     try {
78981       (arg1)->GetNaturalSize(*arg2);
78982     } catch (std::out_of_range& e) {
78983       {
78984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78985       };
78986     } catch (std::exception& e) {
78987       {
78988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78989       };
78990     } catch (...) {
78991       {
78992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78993       };
78994     }
78995   }
78996 }
78997
78998
78999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
79000   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79001   float arg2 ;
79002
79003   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79004   arg2 = (int)jarg2;
79005   {
79006     try {
79007       (arg1)->SetDepthIndex(arg2);
79008     } catch (std::out_of_range& e) {
79009       {
79010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79011       };
79012     } catch (std::exception& e) {
79013       {
79014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79015       };
79016     } catch (...) {
79017       {
79018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79019       };
79020     }
79021   }
79022 }
79023
79024
79025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
79026   int jresult ;
79027   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79028   int result;
79029
79030   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79031   {
79032     try {
79033       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
79034     } catch (std::out_of_range& e) {
79035       {
79036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79037       };
79038     } catch (std::exception& e) {
79039       {
79040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79041       };
79042     } catch (...) {
79043       {
79044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79045       };
79046     }
79047   }
79048   jresult = result;
79049   return jresult;
79050 }
79051
79052
79053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
79054   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79055   Dali::Property::Map *arg2 = 0 ;
79056
79057   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79058   arg2 = (Dali::Property::Map *)jarg2;
79059   if (!arg2) {
79060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
79061     return ;
79062   }
79063   {
79064     try {
79065       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
79066     } catch (std::out_of_range& e) {
79067       {
79068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79069       };
79070     } catch (std::exception& e) {
79071       {
79072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79073       };
79074     } catch (...) {
79075       {
79076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79077       };
79078     }
79079   }
79080 }
79081
79082
79083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
79084   void * jresult ;
79085   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
79086   Dali::Toolkit::Visual::Base *result = 0 ;
79087
79088   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
79089   {
79090     try {
79091       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
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 = (void *)result;
79107   return jresult;
79108 }
79109
79110
79111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
79112   void * jresult ;
79113   Dali::Toolkit::VisualFactory result;
79114
79115   {
79116     try {
79117       result = Dali::Toolkit::VisualFactory::Get();
79118     } catch (std::out_of_range& e) {
79119       {
79120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79121       };
79122     } catch (std::exception& e) {
79123       {
79124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79125       };
79126     } catch (...) {
79127       {
79128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79129       };
79130     }
79131   }
79132   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
79133   return jresult;
79134 }
79135
79136
79137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
79138   void * jresult ;
79139   Dali::Toolkit::VisualFactory *result = 0 ;
79140
79141   {
79142     try {
79143       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
79144     } catch (std::out_of_range& e) {
79145       {
79146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79147       };
79148     } catch (std::exception& e) {
79149       {
79150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79151       };
79152     } catch (...) {
79153       {
79154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79155       };
79156     }
79157   }
79158   jresult = (void *)result;
79159   return jresult;
79160 }
79161
79162
79163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
79164   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79165
79166   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79167   {
79168     try {
79169       delete arg1;
79170     } catch (std::out_of_range& e) {
79171       {
79172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79173       };
79174     } catch (std::exception& e) {
79175       {
79176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79177       };
79178     } catch (...) {
79179       {
79180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79181       };
79182     }
79183   }
79184 }
79185
79186
79187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
79188   void * jresult ;
79189   Dali::Toolkit::VisualFactory *arg1 = 0 ;
79190   Dali::Toolkit::VisualFactory *result = 0 ;
79191
79192   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79193   if (!arg1) {
79194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
79195     return 0;
79196   }
79197   {
79198     try {
79199       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
79200     } catch (std::out_of_range& e) {
79201       {
79202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79203       };
79204     } catch (std::exception& e) {
79205       {
79206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79207       };
79208     } catch (...) {
79209       {
79210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79211       };
79212     }
79213   }
79214   jresult = (void *)result;
79215   return jresult;
79216 }
79217
79218
79219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
79220   void * jresult ;
79221   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79222   Dali::Toolkit::VisualFactory *arg2 = 0 ;
79223   Dali::Toolkit::VisualFactory *result = 0 ;
79224
79225   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79226   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
79227   if (!arg2) {
79228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
79229     return 0;
79230   }
79231   {
79232     try {
79233       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
79234     } catch (std::out_of_range& e) {
79235       {
79236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79237       };
79238     } catch (std::exception& e) {
79239       {
79240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79241       };
79242     } catch (...) {
79243       {
79244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79245       };
79246     }
79247   }
79248   jresult = (void *)result;
79249   return jresult;
79250 }
79251
79252
79253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
79254   void * jresult ;
79255   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79256   Dali::Property::Map *arg2 = 0 ;
79257   Dali::Toolkit::Visual::Base result;
79258
79259   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79260   arg2 = (Dali::Property::Map *)jarg2;
79261   if (!arg2) {
79262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
79263     return 0;
79264   }
79265   {
79266     try {
79267       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
79268     } catch (std::out_of_range& e) {
79269       {
79270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79271       };
79272     } catch (std::exception& e) {
79273       {
79274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79275       };
79276     } catch (...) {
79277       {
79278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79279       };
79280     }
79281   }
79282   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79283   return jresult;
79284 }
79285
79286
79287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
79288   void * jresult ;
79289   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79290   Dali::Image *arg2 = 0 ;
79291   Dali::Toolkit::Visual::Base result;
79292
79293   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79294   arg2 = (Dali::Image *)jarg2;
79295   if (!arg2) {
79296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
79297     return 0;
79298   }
79299   {
79300     try {
79301       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
79302     } catch (std::out_of_range& e) {
79303       {
79304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79305       };
79306     } catch (std::exception& e) {
79307       {
79308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79309       };
79310     } catch (...) {
79311       {
79312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79313       };
79314     }
79315   }
79316   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79317   return jresult;
79318 }
79319
79320
79321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
79322   void * jresult ;
79323   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79324   std::string *arg2 = 0 ;
79325   Dali::ImageDimensions arg3 ;
79326   Dali::ImageDimensions *argp3 ;
79327   Dali::Toolkit::Visual::Base result;
79328
79329   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79330   if (!jarg2) {
79331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79332     return 0;
79333   }
79334   std::string arg2_str(jarg2);
79335   arg2 = &arg2_str;
79336   argp3 = (Dali::ImageDimensions *)jarg3;
79337   if (!argp3) {
79338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79339     return 0;
79340   }
79341   arg3 = *argp3;
79342   {
79343     try {
79344       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
79345     } catch (std::out_of_range& e) {
79346       {
79347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79348       };
79349     } catch (std::exception& e) {
79350       {
79351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79352       };
79353     } catch (...) {
79354       {
79355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79356       };
79357     }
79358   }
79359   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79360
79361   //argout typemap for const std::string&
79362
79363   return jresult;
79364 }
79365
79366
79367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
79368   void * jresult ;
79369   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79370
79371   {
79372     try {
79373       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
79374     } catch (std::out_of_range& e) {
79375       {
79376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79377       };
79378     } catch (std::exception& e) {
79379       {
79380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79381       };
79382     } catch (...) {
79383       {
79384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79385       };
79386     }
79387   }
79388   jresult = (void *)result;
79389   return jresult;
79390 }
79391
79392
79393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
79394   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79395
79396   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79397   {
79398     try {
79399       delete arg1;
79400     } catch (std::out_of_range& e) {
79401       {
79402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79403       };
79404     } catch (std::exception& e) {
79405       {
79406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79407       };
79408     } catch (...) {
79409       {
79410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79411       };
79412     }
79413   }
79414 }
79415
79416
79417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
79418   void * jresult ;
79419   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
79420   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79421
79422   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79423   if (!arg1) {
79424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
79425     return 0;
79426   }
79427   {
79428     try {
79429       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
79430     } catch (std::out_of_range& e) {
79431       {
79432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79433       };
79434     } catch (std::exception& e) {
79435       {
79436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79437       };
79438     } catch (...) {
79439       {
79440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79441       };
79442     }
79443   }
79444   jresult = (void *)result;
79445   return jresult;
79446 }
79447
79448
79449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
79450   void * jresult ;
79451   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79452   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
79453   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79454
79455   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79456   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
79457   if (!arg2) {
79458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
79459     return 0;
79460   }
79461   {
79462     try {
79463       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
79464     } catch (std::out_of_range& e) {
79465       {
79466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79467       };
79468     } catch (std::exception& e) {
79469       {
79470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79471       };
79472     } catch (...) {
79473       {
79474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79475       };
79476     }
79477   }
79478   jresult = (void *)result;
79479   return jresult;
79480 }
79481
79482
79483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
79484   void * jresult ;
79485   Dali::Toolkit::AsyncImageLoader result;
79486
79487   {
79488     try {
79489       result = Dali::Toolkit::AsyncImageLoader::New();
79490     } catch (std::out_of_range& e) {
79491       {
79492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79493       };
79494     } catch (std::exception& e) {
79495       {
79496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79497       };
79498     } catch (...) {
79499       {
79500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79501       };
79502     }
79503   }
79504   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
79505   return jresult;
79506 }
79507
79508
79509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
79510   void * jresult ;
79511   Dali::BaseHandle arg1 ;
79512   Dali::BaseHandle *argp1 ;
79513   Dali::Toolkit::AsyncImageLoader result;
79514
79515   argp1 = (Dali::BaseHandle *)jarg1;
79516   if (!argp1) {
79517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79518     return 0;
79519   }
79520   arg1 = *argp1;
79521   {
79522     try {
79523       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
79524     } catch (std::out_of_range& e) {
79525       {
79526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79527       };
79528     } catch (std::exception& e) {
79529       {
79530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79531       };
79532     } catch (...) {
79533       {
79534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79535       };
79536     }
79537   }
79538   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
79539   return jresult;
79540 }
79541
79542
79543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
79544   unsigned int jresult ;
79545   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79546   std::string *arg2 = 0 ;
79547   uint32_t result;
79548
79549   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79550   if (!jarg2) {
79551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79552     return 0;
79553   }
79554   std::string arg2_str(jarg2);
79555   arg2 = &arg2_str;
79556   {
79557     try {
79558       result = (arg1)->Load((std::string const &)*arg2);
79559     } catch (std::out_of_range& e) {
79560       {
79561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79562       };
79563     } catch (std::exception& e) {
79564       {
79565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79566       };
79567     } catch (...) {
79568       {
79569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79570       };
79571     }
79572   }
79573   jresult = result;
79574
79575   //argout typemap for const std::string&
79576
79577   return jresult;
79578 }
79579
79580
79581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
79582   unsigned int jresult ;
79583   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79584   std::string *arg2 = 0 ;
79585   Dali::ImageDimensions arg3 ;
79586   Dali::ImageDimensions *argp3 ;
79587   uint32_t result;
79588
79589   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79590   if (!jarg2) {
79591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79592     return 0;
79593   }
79594   std::string arg2_str(jarg2);
79595   arg2 = &arg2_str;
79596   argp3 = (Dali::ImageDimensions *)jarg3;
79597   if (!argp3) {
79598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79599     return 0;
79600   }
79601   arg3 = *argp3;
79602   {
79603     try {
79604       result = (arg1)->Load((std::string const &)*arg2,arg3);
79605     } catch (std::out_of_range& e) {
79606       {
79607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79608       };
79609     } catch (std::exception& e) {
79610       {
79611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79612       };
79613     } catch (...) {
79614       {
79615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79616       };
79617     }
79618   }
79619   jresult = result;
79620
79621   //argout typemap for const std::string&
79622
79623   return jresult;
79624 }
79625
79626
79627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
79628   unsigned int jresult ;
79629   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79630   std::string *arg2 = 0 ;
79631   Dali::ImageDimensions arg3 ;
79632   Dali::FittingMode::Type arg4 ;
79633   Dali::SamplingMode::Type arg5 ;
79634   bool arg6 ;
79635   Dali::ImageDimensions *argp3 ;
79636   uint32_t result;
79637
79638   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79639   if (!jarg2) {
79640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79641     return 0;
79642   }
79643   std::string arg2_str(jarg2);
79644   arg2 = &arg2_str;
79645   argp3 = (Dali::ImageDimensions *)jarg3;
79646   if (!argp3) {
79647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79648     return 0;
79649   }
79650   arg3 = *argp3;
79651   arg4 = (Dali::FittingMode::Type)jarg4;
79652   arg5 = (Dali::SamplingMode::Type)jarg5;
79653   arg6 = jarg6 ? true : false;
79654   {
79655     try {
79656       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
79657     } catch (std::out_of_range& e) {
79658       {
79659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79660       };
79661     } catch (std::exception& e) {
79662       {
79663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79664       };
79665     } catch (...) {
79666       {
79667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79668       };
79669     }
79670   }
79671   jresult = result;
79672
79673   //argout typemap for const std::string&
79674
79675   return jresult;
79676 }
79677
79678
79679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
79680   unsigned int jresult ;
79681   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79682   uint32_t arg2 ;
79683   bool result;
79684
79685   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79686   arg2 = (uint32_t)jarg2;
79687   {
79688     try {
79689       result = (bool)(arg1)->Cancel(arg2);
79690     } catch (std::out_of_range& e) {
79691       {
79692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79693       };
79694     } catch (std::exception& e) {
79695       {
79696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79697       };
79698     } catch (...) {
79699       {
79700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79701       };
79702     }
79703   }
79704   jresult = result;
79705   return jresult;
79706 }
79707
79708
79709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
79710   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79711
79712   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79713   {
79714     try {
79715       (arg1)->CancelAll();
79716     } catch (std::out_of_range& e) {
79717       {
79718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79719       };
79720     } catch (std::exception& e) {
79721       {
79722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79723       };
79724     } catch (...) {
79725       {
79726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79727       };
79728     }
79729   }
79730 }
79731
79732
79733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
79734   void * jresult ;
79735   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79736   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
79737
79738   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79739   {
79740     try {
79741       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
79742     } catch (std::out_of_range& e) {
79743       {
79744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79745       };
79746     } catch (std::exception& e) {
79747       {
79748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79749       };
79750     } catch (...) {
79751       {
79752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79753       };
79754     }
79755   }
79756   jresult = (void *)result;
79757   return jresult;
79758 }
79759
79760
79761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
79762   void * jresult ;
79763   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
79764   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79765
79766   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
79767   {
79768     try {
79769       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
79770     } catch (std::out_of_range& e) {
79771       {
79772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79773       };
79774     } catch (std::exception& e) {
79775       {
79776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79777       };
79778     } catch (...) {
79779       {
79780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79781       };
79782     }
79783   }
79784   jresult = (void *)result;
79785   return jresult;
79786 }
79787
79788
79789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
79790   void * jresult ;
79791   std::string *arg1 = 0 ;
79792   Dali::PixelData result;
79793
79794   if (!jarg1) {
79795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79796     return 0;
79797   }
79798   std::string arg1_str(jarg1);
79799   arg1 = &arg1_str;
79800   {
79801     try {
79802       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
79803     } catch (std::out_of_range& e) {
79804       {
79805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79806       };
79807     } catch (std::exception& e) {
79808       {
79809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79810       };
79811     } catch (...) {
79812       {
79813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79814       };
79815     }
79816   }
79817   jresult = new Dali::PixelData((const Dali::PixelData &)result);
79818
79819   //argout typemap for const std::string&
79820
79821   return jresult;
79822 }
79823
79824
79825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
79826   void * jresult ;
79827   std::string *arg1 = 0 ;
79828   Dali::ImageDimensions arg2 ;
79829   Dali::ImageDimensions *argp2 ;
79830   Dali::PixelData result;
79831
79832   if (!jarg1) {
79833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79834     return 0;
79835   }
79836   std::string arg1_str(jarg1);
79837   arg1 = &arg1_str;
79838   argp2 = (Dali::ImageDimensions *)jarg2;
79839   if (!argp2) {
79840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79841     return 0;
79842   }
79843   arg2 = *argp2;
79844   {
79845     try {
79846       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
79847     } catch (std::out_of_range& e) {
79848       {
79849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79850       };
79851     } catch (std::exception& e) {
79852       {
79853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79854       };
79855     } catch (...) {
79856       {
79857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79858       };
79859     }
79860   }
79861   jresult = new Dali::PixelData((const Dali::PixelData &)result);
79862
79863   //argout typemap for const std::string&
79864
79865   return jresult;
79866 }
79867
79868
79869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
79870   void * jresult ;
79871   std::string *arg1 = 0 ;
79872   Dali::ImageDimensions arg2 ;
79873   Dali::FittingMode::Type arg3 ;
79874   Dali::SamplingMode::Type arg4 ;
79875   bool arg5 ;
79876   Dali::ImageDimensions *argp2 ;
79877   Dali::PixelData result;
79878
79879   if (!jarg1) {
79880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79881     return 0;
79882   }
79883   std::string arg1_str(jarg1);
79884   arg1 = &arg1_str;
79885   argp2 = (Dali::ImageDimensions *)jarg2;
79886   if (!argp2) {
79887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79888     return 0;
79889   }
79890   arg2 = *argp2;
79891   arg3 = (Dali::FittingMode::Type)jarg3;
79892   arg4 = (Dali::SamplingMode::Type)jarg4;
79893   arg5 = jarg5 ? true : false;
79894   {
79895     try {
79896       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
79897     } catch (std::out_of_range& e) {
79898       {
79899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79900       };
79901     } catch (std::exception& e) {
79902       {
79903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79904       };
79905     } catch (...) {
79906       {
79907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79908       };
79909     }
79910   }
79911   jresult = new Dali::PixelData((const Dali::PixelData &)result);
79912
79913   //argout typemap for const std::string&
79914
79915   return jresult;
79916 }
79917
79918
79919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
79920   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
79921
79922   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
79923   {
79924     try {
79925       delete arg1;
79926     } catch (std::out_of_range& e) {
79927       {
79928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79929       };
79930     } catch (std::exception& e) {
79931       {
79932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79933       };
79934     } catch (...) {
79935       {
79936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79937       };
79938     }
79939   }
79940 }
79941
79942
79943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
79944   void * jresult ;
79945   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
79946   Dali::Actor arg2 ;
79947   Dali::Actor arg3 ;
79948   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
79949   Dali::Actor *argp2 ;
79950   Dali::Actor *argp3 ;
79951   Dali::Actor result;
79952
79953   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
79954   argp2 = (Dali::Actor *)jarg2;
79955   if (!argp2) {
79956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79957     return 0;
79958   }
79959   arg2 = *argp2;
79960   argp3 = (Dali::Actor *)jarg3;
79961   if (!argp3) {
79962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79963     return 0;
79964   }
79965   arg3 = *argp3;
79966   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
79967   {
79968     try {
79969       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
79970     } catch (std::out_of_range& e) {
79971       {
79972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79973       };
79974     } catch (std::exception& e) {
79975       {
79976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79977       };
79978     } catch (...) {
79979       {
79980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79981       };
79982     }
79983   }
79984   jresult = new Dali::Actor((const Dali::Actor &)result);
79985   return jresult;
79986 }
79987
79988
79989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
79990   void * jresult ;
79991   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
79992
79993   {
79994     try {
79995       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
79996     } catch (std::out_of_range& e) {
79997       {
79998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79999       };
80000     } catch (std::exception& e) {
80001       {
80002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80003       };
80004     } catch (...) {
80005       {
80006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80007       };
80008     }
80009   }
80010   jresult = (void *)result;
80011   return jresult;
80012 }
80013
80014
80015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
80016   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
80017   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
80018   if (director) {
80019     director->swig_connect_director(callback0);
80020   }
80021 }
80022
80023
80024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
80025   KeyboardFocusManager arg1 ;
80026   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
80027   KeyboardFocusManager *argp1 ;
80028
80029   argp1 = (KeyboardFocusManager *)jarg1;
80030   if (!argp1) {
80031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
80032     return ;
80033   }
80034   arg1 = *argp1;
80035   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
80036   if (!arg2) {
80037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
80038     return ;
80039   }
80040   {
80041     try {
80042       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
80043     } catch (std::out_of_range& e) {
80044       {
80045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80046       };
80047     } catch (std::exception& e) {
80048       {
80049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80050       };
80051     } catch (...) {
80052       {
80053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80054       };
80055     }
80056   }
80057 }
80058
80059
80060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
80061   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80062
80063   arg1 = (std::vector< unsigned int > *)jarg1;
80064   {
80065     try {
80066       (arg1)->clear();
80067     } catch (std::out_of_range& e) {
80068       {
80069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80070       };
80071     } catch (std::exception& e) {
80072       {
80073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80074       };
80075     } catch (...) {
80076       {
80077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80078       };
80079     }
80080   }
80081 }
80082
80083
80084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
80085   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80086   unsigned int *arg2 = 0 ;
80087   unsigned int temp2 ;
80088
80089   arg1 = (std::vector< unsigned int > *)jarg1;
80090   temp2 = (unsigned int)jarg2;
80091   arg2 = &temp2;
80092   {
80093     try {
80094       (arg1)->push_back((unsigned int const &)*arg2);
80095     } catch (std::out_of_range& e) {
80096       {
80097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80098       };
80099     } catch (std::exception& e) {
80100       {
80101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80102       };
80103     } catch (...) {
80104       {
80105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80106       };
80107     }
80108   }
80109 }
80110
80111
80112 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
80113   unsigned long jresult ;
80114   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80115   std::vector< unsigned int >::size_type result;
80116
80117   arg1 = (std::vector< unsigned int > *)jarg1;
80118   {
80119     try {
80120       result = ((std::vector< unsigned int > const *)arg1)->size();
80121     } catch (std::out_of_range& e) {
80122       {
80123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80124       };
80125     } catch (std::exception& e) {
80126       {
80127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80128       };
80129     } catch (...) {
80130       {
80131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80132       };
80133     }
80134   }
80135   jresult = (unsigned long)result;
80136   return jresult;
80137 }
80138
80139
80140 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
80141   unsigned long jresult ;
80142   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80143   std::vector< unsigned int >::size_type result;
80144
80145   arg1 = (std::vector< unsigned int > *)jarg1;
80146   {
80147     try {
80148       result = ((std::vector< unsigned int > const *)arg1)->capacity();
80149     } catch (std::out_of_range& e) {
80150       {
80151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80152       };
80153     } catch (std::exception& e) {
80154       {
80155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80156       };
80157     } catch (...) {
80158       {
80159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80160       };
80161     }
80162   }
80163   jresult = (unsigned long)result;
80164   return jresult;
80165 }
80166
80167
80168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
80169   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80170   std::vector< unsigned int >::size_type arg2 ;
80171
80172   arg1 = (std::vector< unsigned int > *)jarg1;
80173   arg2 = (std::vector< unsigned int >::size_type)jarg2;
80174   {
80175     try {
80176       (arg1)->reserve(arg2);
80177     } catch (std::out_of_range& e) {
80178       {
80179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80180       };
80181     } catch (std::exception& e) {
80182       {
80183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80184       };
80185     } catch (...) {
80186       {
80187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80188       };
80189     }
80190   }
80191 }
80192
80193
80194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
80195   void * jresult ;
80196   std::vector< unsigned int > *result = 0 ;
80197
80198   {
80199     try {
80200       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
80201     } catch (std::out_of_range& e) {
80202       {
80203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80204       };
80205     } catch (std::exception& e) {
80206       {
80207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80208       };
80209     } catch (...) {
80210       {
80211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80212       };
80213     }
80214   }
80215   jresult = (void *)result;
80216   return jresult;
80217 }
80218
80219
80220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
80221   void * jresult ;
80222   std::vector< unsigned int > *arg1 = 0 ;
80223   std::vector< unsigned int > *result = 0 ;
80224
80225   arg1 = (std::vector< unsigned int > *)jarg1;
80226   if (!arg1) {
80227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80228     return 0;
80229   }
80230   {
80231     try {
80232       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
80233     } catch (std::out_of_range& e) {
80234       {
80235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80236       };
80237     } catch (std::exception& e) {
80238       {
80239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80240       };
80241     } catch (...) {
80242       {
80243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80244       };
80245     }
80246   }
80247   jresult = (void *)result;
80248   return jresult;
80249 }
80250
80251
80252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
80253   void * jresult ;
80254   int arg1 ;
80255   std::vector< unsigned int > *result = 0 ;
80256
80257   arg1 = (int)jarg1;
80258   {
80259     try {
80260       try {
80261         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
80262       }
80263       catch(std::out_of_range &_e) {
80264         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80265         return 0;
80266       }
80267
80268     } catch (std::out_of_range& e) {
80269       {
80270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80271       };
80272     } catch (std::exception& e) {
80273       {
80274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80275       };
80276     } catch (...) {
80277       {
80278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80279       };
80280     }
80281   }
80282   jresult = (void *)result;
80283   return jresult;
80284 }
80285
80286
80287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
80288   unsigned int jresult ;
80289   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80290   int arg2 ;
80291   unsigned int result;
80292
80293   arg1 = (std::vector< unsigned int > *)jarg1;
80294   arg2 = (int)jarg2;
80295   {
80296     try {
80297       try {
80298         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
80299       }
80300       catch(std::out_of_range &_e) {
80301         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80302         return 0;
80303       }
80304
80305     } catch (std::out_of_range& e) {
80306       {
80307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80308       };
80309     } catch (std::exception& e) {
80310       {
80311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80312       };
80313     } catch (...) {
80314       {
80315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80316       };
80317     }
80318   }
80319   jresult = result;
80320   return jresult;
80321 }
80322
80323
80324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
80325   unsigned int jresult ;
80326   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80327   int arg2 ;
80328   unsigned int *result = 0 ;
80329
80330   arg1 = (std::vector< unsigned int > *)jarg1;
80331   arg2 = (int)jarg2;
80332   {
80333     try {
80334       try {
80335         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
80336       }
80337       catch(std::out_of_range &_e) {
80338         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80339         return 0;
80340       }
80341
80342     } catch (std::out_of_range& e) {
80343       {
80344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80345       };
80346     } catch (std::exception& e) {
80347       {
80348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80349       };
80350     } catch (...) {
80351       {
80352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80353       };
80354     }
80355   }
80356   jresult = *result;
80357   return jresult;
80358 }
80359
80360
80361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
80362   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80363   int arg2 ;
80364   unsigned int *arg3 = 0 ;
80365   unsigned int temp3 ;
80366
80367   arg1 = (std::vector< unsigned int > *)jarg1;
80368   arg2 = (int)jarg2;
80369   temp3 = (unsigned int)jarg3;
80370   arg3 = &temp3;
80371   {
80372     try {
80373       try {
80374         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
80375       }
80376       catch(std::out_of_range &_e) {
80377         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80378         return ;
80379       }
80380
80381     } catch (std::out_of_range& e) {
80382       {
80383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80384       };
80385     } catch (std::exception& e) {
80386       {
80387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80388       };
80389     } catch (...) {
80390       {
80391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80392       };
80393     }
80394   }
80395 }
80396
80397
80398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
80399   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80400   std::vector< unsigned int > *arg2 = 0 ;
80401
80402   arg1 = (std::vector< unsigned int > *)jarg1;
80403   arg2 = (std::vector< unsigned int > *)jarg2;
80404   if (!arg2) {
80405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80406     return ;
80407   }
80408   {
80409     try {
80410       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
80411     } catch (std::out_of_range& e) {
80412       {
80413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80414       };
80415     } catch (std::exception& e) {
80416       {
80417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80418       };
80419     } catch (...) {
80420       {
80421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80422       };
80423     }
80424   }
80425 }
80426
80427
80428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
80429   void * jresult ;
80430   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80431   int arg2 ;
80432   int arg3 ;
80433   std::vector< unsigned int > *result = 0 ;
80434
80435   arg1 = (std::vector< unsigned int > *)jarg1;
80436   arg2 = (int)jarg2;
80437   arg3 = (int)jarg3;
80438   {
80439     try {
80440       try {
80441         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
80442       }
80443       catch(std::out_of_range &_e) {
80444         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80445         return 0;
80446       }
80447       catch(std::invalid_argument &_e) {
80448         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80449         return 0;
80450       }
80451
80452     } catch (std::out_of_range& e) {
80453       {
80454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80455       };
80456     } catch (std::exception& e) {
80457       {
80458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80459       };
80460     } catch (...) {
80461       {
80462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80463       };
80464     }
80465   }
80466   jresult = (void *)result;
80467   return jresult;
80468 }
80469
80470
80471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
80472   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80473   int arg2 ;
80474   unsigned int *arg3 = 0 ;
80475   unsigned int temp3 ;
80476
80477   arg1 = (std::vector< unsigned int > *)jarg1;
80478   arg2 = (int)jarg2;
80479   temp3 = (unsigned int)jarg3;
80480   arg3 = &temp3;
80481   {
80482     try {
80483       try {
80484         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
80485       }
80486       catch(std::out_of_range &_e) {
80487         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80488         return ;
80489       }
80490
80491     } catch (std::out_of_range& e) {
80492       {
80493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80494       };
80495     } catch (std::exception& e) {
80496       {
80497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80498       };
80499     } catch (...) {
80500       {
80501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80502       };
80503     }
80504   }
80505 }
80506
80507
80508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
80509   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80510   int arg2 ;
80511   std::vector< unsigned int > *arg3 = 0 ;
80512
80513   arg1 = (std::vector< unsigned int > *)jarg1;
80514   arg2 = (int)jarg2;
80515   arg3 = (std::vector< unsigned int > *)jarg3;
80516   if (!arg3) {
80517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80518     return ;
80519   }
80520   {
80521     try {
80522       try {
80523         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
80524       }
80525       catch(std::out_of_range &_e) {
80526         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80527         return ;
80528       }
80529
80530     } catch (std::out_of_range& e) {
80531       {
80532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80533       };
80534     } catch (std::exception& e) {
80535       {
80536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80537       };
80538     } catch (...) {
80539       {
80540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80541       };
80542     }
80543   }
80544 }
80545
80546
80547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
80548   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80549   int arg2 ;
80550
80551   arg1 = (std::vector< unsigned int > *)jarg1;
80552   arg2 = (int)jarg2;
80553   {
80554     try {
80555       try {
80556         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
80557       }
80558       catch(std::out_of_range &_e) {
80559         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80560         return ;
80561       }
80562
80563     } catch (std::out_of_range& e) {
80564       {
80565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80566       };
80567     } catch (std::exception& e) {
80568       {
80569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80570       };
80571     } catch (...) {
80572       {
80573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80574       };
80575     }
80576   }
80577 }
80578
80579
80580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
80581   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80582   int arg2 ;
80583   int arg3 ;
80584
80585   arg1 = (std::vector< unsigned int > *)jarg1;
80586   arg2 = (int)jarg2;
80587   arg3 = (int)jarg3;
80588   {
80589     try {
80590       try {
80591         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
80592       }
80593       catch(std::out_of_range &_e) {
80594         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80595         return ;
80596       }
80597       catch(std::invalid_argument &_e) {
80598         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80599         return ;
80600       }
80601
80602     } catch (std::out_of_range& e) {
80603       {
80604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80605       };
80606     } catch (std::exception& e) {
80607       {
80608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80609       };
80610     } catch (...) {
80611       {
80612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80613       };
80614     }
80615   }
80616 }
80617
80618
80619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
80620   void * jresult ;
80621   unsigned int *arg1 = 0 ;
80622   int arg2 ;
80623   unsigned int temp1 ;
80624   std::vector< unsigned int > *result = 0 ;
80625
80626   temp1 = (unsigned int)jarg1;
80627   arg1 = &temp1;
80628   arg2 = (int)jarg2;
80629   {
80630     try {
80631       try {
80632         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
80633       }
80634       catch(std::out_of_range &_e) {
80635         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80636         return 0;
80637       }
80638
80639     } catch (std::out_of_range& e) {
80640       {
80641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80642       };
80643     } catch (std::exception& e) {
80644       {
80645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80646       };
80647     } catch (...) {
80648       {
80649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80650       };
80651     }
80652   }
80653   jresult = (void *)result;
80654   return jresult;
80655 }
80656
80657
80658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
80659   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80660
80661   arg1 = (std::vector< unsigned int > *)jarg1;
80662   {
80663     try {
80664       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
80665     } catch (std::out_of_range& e) {
80666       {
80667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80668       };
80669     } catch (std::exception& e) {
80670       {
80671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80672       };
80673     } catch (...) {
80674       {
80675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80676       };
80677     }
80678   }
80679 }
80680
80681
80682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
80683   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80684   int arg2 ;
80685   int arg3 ;
80686
80687   arg1 = (std::vector< unsigned int > *)jarg1;
80688   arg2 = (int)jarg2;
80689   arg3 = (int)jarg3;
80690   {
80691     try {
80692       try {
80693         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
80694       }
80695       catch(std::out_of_range &_e) {
80696         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80697         return ;
80698       }
80699       catch(std::invalid_argument &_e) {
80700         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80701         return ;
80702       }
80703
80704     } catch (std::out_of_range& e) {
80705       {
80706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80707       };
80708     } catch (std::exception& e) {
80709       {
80710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80711       };
80712     } catch (...) {
80713       {
80714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80715       };
80716     }
80717   }
80718 }
80719
80720
80721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
80722   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80723   int arg2 ;
80724   std::vector< unsigned int > *arg3 = 0 ;
80725
80726   arg1 = (std::vector< unsigned int > *)jarg1;
80727   arg2 = (int)jarg2;
80728   arg3 = (std::vector< unsigned int > *)jarg3;
80729   if (!arg3) {
80730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80731     return ;
80732   }
80733   {
80734     try {
80735       try {
80736         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
80737       }
80738       catch(std::out_of_range &_e) {
80739         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80740         return ;
80741       }
80742
80743     } catch (std::out_of_range& e) {
80744       {
80745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80746       };
80747     } catch (std::exception& e) {
80748       {
80749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80750       };
80751     } catch (...) {
80752       {
80753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80754       };
80755     }
80756   }
80757 }
80758
80759
80760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
80761   unsigned int jresult ;
80762   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80763   unsigned int *arg2 = 0 ;
80764   unsigned int temp2 ;
80765   bool result;
80766
80767   arg1 = (std::vector< unsigned int > *)jarg1;
80768   temp2 = (unsigned int)jarg2;
80769   arg2 = &temp2;
80770   {
80771     try {
80772       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
80773     } catch (std::out_of_range& e) {
80774       {
80775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80776       };
80777     } catch (std::exception& e) {
80778       {
80779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80780       };
80781     } catch (...) {
80782       {
80783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80784       };
80785     }
80786   }
80787   jresult = result;
80788   return jresult;
80789 }
80790
80791
80792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
80793   int jresult ;
80794   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80795   unsigned int *arg2 = 0 ;
80796   unsigned int temp2 ;
80797   int result;
80798
80799   arg1 = (std::vector< unsigned int > *)jarg1;
80800   temp2 = (unsigned int)jarg2;
80801   arg2 = &temp2;
80802   {
80803     try {
80804       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
80805     } catch (std::out_of_range& e) {
80806       {
80807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80808       };
80809     } catch (std::exception& e) {
80810       {
80811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80812       };
80813     } catch (...) {
80814       {
80815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80816       };
80817     }
80818   }
80819   jresult = result;
80820   return jresult;
80821 }
80822
80823
80824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
80825   int jresult ;
80826   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80827   unsigned int *arg2 = 0 ;
80828   unsigned int temp2 ;
80829   int result;
80830
80831   arg1 = (std::vector< unsigned int > *)jarg1;
80832   temp2 = (unsigned int)jarg2;
80833   arg2 = &temp2;
80834   {
80835     try {
80836       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
80837     } catch (std::out_of_range& e) {
80838       {
80839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80840       };
80841     } catch (std::exception& e) {
80842       {
80843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80844       };
80845     } catch (...) {
80846       {
80847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80848       };
80849     }
80850   }
80851   jresult = result;
80852   return jresult;
80853 }
80854
80855
80856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
80857   unsigned int jresult ;
80858   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80859   unsigned int *arg2 = 0 ;
80860   unsigned int temp2 ;
80861   bool result;
80862
80863   arg1 = (std::vector< unsigned int > *)jarg1;
80864   temp2 = (unsigned int)jarg2;
80865   arg2 = &temp2;
80866   {
80867     try {
80868       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
80869     } catch (std::out_of_range& e) {
80870       {
80871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80872       };
80873     } catch (std::exception& e) {
80874       {
80875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80876       };
80877     } catch (...) {
80878       {
80879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80880       };
80881     }
80882   }
80883   jresult = result;
80884   return jresult;
80885 }
80886
80887
80888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
80889   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80890
80891   arg1 = (std::vector< unsigned int > *)jarg1;
80892   {
80893     try {
80894       delete arg1;
80895     } catch (std::out_of_range& e) {
80896       {
80897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80898       };
80899     } catch (std::exception& e) {
80900       {
80901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80902       };
80903     } catch (...) {
80904       {
80905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80906       };
80907     }
80908   }
80909 }
80910
80911
80912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
80913   void * jresult ;
80914   std::pair< unsigned int,Dali::Actor > *result = 0 ;
80915
80916   {
80917     try {
80918       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
80919     } catch (std::out_of_range& e) {
80920       {
80921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80922       };
80923     } catch (std::exception& e) {
80924       {
80925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80926       };
80927     } catch (...) {
80928       {
80929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80930       };
80931     }
80932   }
80933   jresult = (void *)result;
80934   return jresult;
80935 }
80936
80937
80938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
80939   void * jresult ;
80940   unsigned int arg1 ;
80941   Dali::Actor arg2 ;
80942   Dali::Actor *argp2 ;
80943   std::pair< unsigned int,Dali::Actor > *result = 0 ;
80944
80945   arg1 = (unsigned int)jarg1;
80946   argp2 = (Dali::Actor *)jarg2;
80947   if (!argp2) {
80948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80949     return 0;
80950   }
80951   arg2 = *argp2;
80952   {
80953     try {
80954       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
80955     } catch (std::out_of_range& e) {
80956       {
80957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80958       };
80959     } catch (std::exception& e) {
80960       {
80961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80962       };
80963     } catch (...) {
80964       {
80965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80966       };
80967     }
80968   }
80969   jresult = (void *)result;
80970   return jresult;
80971 }
80972
80973
80974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
80975   void * jresult ;
80976   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
80977   std::pair< unsigned int,Dali::Actor > *result = 0 ;
80978
80979   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
80980   if (!arg1) {
80981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
80982     return 0;
80983   }
80984   {
80985     try {
80986       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
80987     } catch (std::out_of_range& e) {
80988       {
80989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80990       };
80991     } catch (std::exception& e) {
80992       {
80993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80994       };
80995     } catch (...) {
80996       {
80997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80998       };
80999     }
81000   }
81001   jresult = (void *)result;
81002   return jresult;
81003 }
81004
81005
81006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
81007   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81008   unsigned int arg2 ;
81009
81010   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81011   arg2 = (unsigned int)jarg2;
81012   if (arg1) (arg1)->first = arg2;
81013 }
81014
81015
81016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
81017   unsigned int jresult ;
81018   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81019   unsigned int result;
81020
81021   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81022   result = (unsigned int) ((arg1)->first);
81023   jresult = result;
81024   return jresult;
81025 }
81026
81027
81028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
81029   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81030   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
81031
81032   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81033   arg2 = (Dali::Actor *)jarg2;
81034   if (arg1) (arg1)->second = *arg2;
81035 }
81036
81037
81038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
81039   void * jresult ;
81040   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81041   Dali::Actor *result = 0 ;
81042
81043   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81044   result = (Dali::Actor *)& ((arg1)->second);
81045   jresult = (void *)result;
81046   return jresult;
81047 }
81048
81049
81050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
81051   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81052
81053   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81054   {
81055     try {
81056       delete arg1;
81057     } catch (std::out_of_range& e) {
81058       {
81059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81060       };
81061     } catch (std::exception& e) {
81062       {
81063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81064       };
81065     } catch (...) {
81066       {
81067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81068       };
81069     }
81070   }
81071 }
81072
81073
81074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
81075   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81076
81077   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81078   {
81079     try {
81080       (arg1)->clear();
81081     } catch (std::out_of_range& e) {
81082       {
81083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81084       };
81085     } catch (std::exception& e) {
81086       {
81087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81088       };
81089     } catch (...) {
81090       {
81091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81092       };
81093     }
81094   }
81095 }
81096
81097
81098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
81099   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81100   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
81101
81102   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81103   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
81104   if (!arg2) {
81105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81106     return ;
81107   }
81108   {
81109     try {
81110       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
81111     } catch (std::out_of_range& e) {
81112       {
81113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81114       };
81115     } catch (std::exception& e) {
81116       {
81117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81118       };
81119     } catch (...) {
81120       {
81121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81122       };
81123     }
81124   }
81125 }
81126
81127
81128 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
81129   unsigned long jresult ;
81130   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81131   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
81132
81133   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81134   {
81135     try {
81136       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
81137     } catch (std::out_of_range& e) {
81138       {
81139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81140       };
81141     } catch (std::exception& e) {
81142       {
81143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81144       };
81145     } catch (...) {
81146       {
81147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81148       };
81149     }
81150   }
81151   jresult = (unsigned long)result;
81152   return jresult;
81153 }
81154
81155
81156 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
81157   unsigned long jresult ;
81158   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81159   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
81160
81161   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81162   {
81163     try {
81164       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
81165     } catch (std::out_of_range& e) {
81166       {
81167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81168       };
81169     } catch (std::exception& e) {
81170       {
81171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81172       };
81173     } catch (...) {
81174       {
81175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81176       };
81177     }
81178   }
81179   jresult = (unsigned long)result;
81180   return jresult;
81181 }
81182
81183
81184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
81185   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81186   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
81187
81188   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81189   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
81190   {
81191     try {
81192       (arg1)->reserve(arg2);
81193     } catch (std::out_of_range& e) {
81194       {
81195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81196       };
81197     } catch (std::exception& e) {
81198       {
81199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81200       };
81201     } catch (...) {
81202       {
81203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81204       };
81205     }
81206   }
81207 }
81208
81209
81210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
81211   void * jresult ;
81212   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81213
81214   {
81215     try {
81216       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
81217     } catch (std::out_of_range& e) {
81218       {
81219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81220       };
81221     } catch (std::exception& e) {
81222       {
81223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81224       };
81225     } catch (...) {
81226       {
81227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81228       };
81229     }
81230   }
81231   jresult = (void *)result;
81232   return jresult;
81233 }
81234
81235
81236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
81237   void * jresult ;
81238   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
81239   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81240
81241   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81242   if (!arg1) {
81243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81244     return 0;
81245   }
81246   {
81247     try {
81248       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);
81249     } catch (std::out_of_range& e) {
81250       {
81251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81252       };
81253     } catch (std::exception& e) {
81254       {
81255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81256       };
81257     } catch (...) {
81258       {
81259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81260       };
81261     }
81262   }
81263   jresult = (void *)result;
81264   return jresult;
81265 }
81266
81267
81268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
81269   void * jresult ;
81270   int arg1 ;
81271   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81272
81273   arg1 = (int)jarg1;
81274   {
81275     try {
81276       try {
81277         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);
81278       }
81279       catch(std::out_of_range &_e) {
81280         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81281         return 0;
81282       }
81283
81284     } catch (std::out_of_range& e) {
81285       {
81286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81287       };
81288     } catch (std::exception& e) {
81289       {
81290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81291       };
81292     } catch (...) {
81293       {
81294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81295       };
81296     }
81297   }
81298   jresult = (void *)result;
81299   return jresult;
81300 }
81301
81302
81303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
81304   void * jresult ;
81305   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81306   int arg2 ;
81307   std::pair< unsigned int,Dali::Actor > result;
81308
81309   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81310   arg2 = (int)jarg2;
81311   {
81312     try {
81313       try {
81314         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
81315       }
81316       catch(std::out_of_range &_e) {
81317         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81318         return 0;
81319       }
81320
81321     } catch (std::out_of_range& e) {
81322       {
81323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81324       };
81325     } catch (std::exception& e) {
81326       {
81327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81328       };
81329     } catch (...) {
81330       {
81331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81332       };
81333     }
81334   }
81335   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
81336   return jresult;
81337 }
81338
81339
81340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
81341   void * jresult ;
81342   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81343   int arg2 ;
81344   std::pair< unsigned int,Dali::Actor > *result = 0 ;
81345
81346   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81347   arg2 = (int)jarg2;
81348   {
81349     try {
81350       try {
81351         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
81352       }
81353       catch(std::out_of_range &_e) {
81354         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81355         return 0;
81356       }
81357
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_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
81378   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81379   int arg2 ;
81380   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
81381
81382   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81383   arg2 = (int)jarg2;
81384   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
81385   if (!arg3) {
81386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81387     return ;
81388   }
81389   {
81390     try {
81391       try {
81392         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);
81393       }
81394       catch(std::out_of_range &_e) {
81395         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81396         return ;
81397       }
81398
81399     } catch (std::out_of_range& e) {
81400       {
81401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81402       };
81403     } catch (std::exception& e) {
81404       {
81405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81406       };
81407     } catch (...) {
81408       {
81409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81410       };
81411     }
81412   }
81413 }
81414
81415
81416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
81417   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81418   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
81419
81420   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81421   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
81422   if (!arg2) {
81423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81424     return ;
81425   }
81426   {
81427     try {
81428       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);
81429     } catch (std::out_of_range& e) {
81430       {
81431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81432       };
81433     } catch (std::exception& e) {
81434       {
81435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81436       };
81437     } catch (...) {
81438       {
81439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81440       };
81441     }
81442   }
81443 }
81444
81445
81446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
81447   void * jresult ;
81448   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81449   int arg2 ;
81450   int arg3 ;
81451   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81452
81453   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81454   arg2 = (int)jarg2;
81455   arg3 = (int)jarg3;
81456   {
81457     try {
81458       try {
81459         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);
81460       }
81461       catch(std::out_of_range &_e) {
81462         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81463         return 0;
81464       }
81465       catch(std::invalid_argument &_e) {
81466         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81467         return 0;
81468       }
81469
81470     } catch (std::out_of_range& e) {
81471       {
81472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81473       };
81474     } catch (std::exception& e) {
81475       {
81476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81477       };
81478     } catch (...) {
81479       {
81480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81481       };
81482     }
81483   }
81484   jresult = (void *)result;
81485   return jresult;
81486 }
81487
81488
81489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
81490   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81491   int arg2 ;
81492   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
81493
81494   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81495   arg2 = (int)jarg2;
81496   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
81497   if (!arg3) {
81498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81499     return ;
81500   }
81501   {
81502     try {
81503       try {
81504         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);
81505       }
81506       catch(std::out_of_range &_e) {
81507         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81508         return ;
81509       }
81510
81511     } catch (std::out_of_range& e) {
81512       {
81513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81514       };
81515     } catch (std::exception& e) {
81516       {
81517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81518       };
81519     } catch (...) {
81520       {
81521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81522       };
81523     }
81524   }
81525 }
81526
81527
81528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
81529   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81530   int arg2 ;
81531   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
81532
81533   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81534   arg2 = (int)jarg2;
81535   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
81536   if (!arg3) {
81537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81538     return ;
81539   }
81540   {
81541     try {
81542       try {
81543         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);
81544       }
81545       catch(std::out_of_range &_e) {
81546         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81547         return ;
81548       }
81549
81550     } catch (std::out_of_range& e) {
81551       {
81552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81553       };
81554     } catch (std::exception& e) {
81555       {
81556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81557       };
81558     } catch (...) {
81559       {
81560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81561       };
81562     }
81563   }
81564 }
81565
81566
81567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
81568   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81569   int arg2 ;
81570
81571   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81572   arg2 = (int)jarg2;
81573   {
81574     try {
81575       try {
81576         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
81577       }
81578       catch(std::out_of_range &_e) {
81579         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81580         return ;
81581       }
81582
81583     } catch (std::out_of_range& e) {
81584       {
81585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81586       };
81587     } catch (std::exception& e) {
81588       {
81589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81590       };
81591     } catch (...) {
81592       {
81593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81594       };
81595     }
81596   }
81597 }
81598
81599
81600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
81601   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81602   int arg2 ;
81603   int arg3 ;
81604
81605   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81606   arg2 = (int)jarg2;
81607   arg3 = (int)jarg3;
81608   {
81609     try {
81610       try {
81611         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
81612       }
81613       catch(std::out_of_range &_e) {
81614         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81615         return ;
81616       }
81617       catch(std::invalid_argument &_e) {
81618         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81619         return ;
81620       }
81621
81622     } catch (std::out_of_range& e) {
81623       {
81624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81625       };
81626     } catch (std::exception& e) {
81627       {
81628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81629       };
81630     } catch (...) {
81631       {
81632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81633       };
81634     }
81635   }
81636 }
81637
81638
81639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
81640   void * jresult ;
81641   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
81642   int arg2 ;
81643   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81644
81645   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81646   if (!arg1) {
81647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81648     return 0;
81649   }
81650   arg2 = (int)jarg2;
81651   {
81652     try {
81653       try {
81654         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);
81655       }
81656       catch(std::out_of_range &_e) {
81657         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81658         return 0;
81659       }
81660
81661     } catch (std::out_of_range& e) {
81662       {
81663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81664       };
81665     } catch (std::exception& e) {
81666       {
81667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81668       };
81669     } catch (...) {
81670       {
81671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81672       };
81673     }
81674   }
81675   jresult = (void *)result;
81676   return jresult;
81677 }
81678
81679
81680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
81681   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81682
81683   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81684   {
81685     try {
81686       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
81687     } catch (std::out_of_range& e) {
81688       {
81689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81690       };
81691     } catch (std::exception& e) {
81692       {
81693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81694       };
81695     } catch (...) {
81696       {
81697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81698       };
81699     }
81700   }
81701 }
81702
81703
81704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
81705   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81706   int arg2 ;
81707   int arg3 ;
81708
81709   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81710   arg2 = (int)jarg2;
81711   arg3 = (int)jarg3;
81712   {
81713     try {
81714       try {
81715         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
81716       }
81717       catch(std::out_of_range &_e) {
81718         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81719         return ;
81720       }
81721       catch(std::invalid_argument &_e) {
81722         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81723         return ;
81724       }
81725
81726     } catch (std::out_of_range& e) {
81727       {
81728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81729       };
81730     } catch (std::exception& e) {
81731       {
81732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81733       };
81734     } catch (...) {
81735       {
81736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81737       };
81738     }
81739   }
81740 }
81741
81742
81743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
81744   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81745   int arg2 ;
81746   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
81747
81748   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81749   arg2 = (int)jarg2;
81750   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
81751   if (!arg3) {
81752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81753     return ;
81754   }
81755   {
81756     try {
81757       try {
81758         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);
81759       }
81760       catch(std::out_of_range &_e) {
81761         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81762         return ;
81763       }
81764
81765     } catch (std::out_of_range& e) {
81766       {
81767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81768       };
81769     } catch (std::exception& e) {
81770       {
81771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81772       };
81773     } catch (...) {
81774       {
81775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81776       };
81777     }
81778   }
81779 }
81780
81781
81782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
81783   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81784
81785   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81786   {
81787     try {
81788       delete arg1;
81789     } catch (std::out_of_range& e) {
81790       {
81791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81792       };
81793     } catch (std::exception& e) {
81794       {
81795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81796       };
81797     } catch (...) {
81798       {
81799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81800       };
81801     }
81802   }
81803 }
81804
81805
81806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
81807   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81808
81809   arg1 = (std::vector< Dali::Actor > *)jarg1;
81810   {
81811     try {
81812       (arg1)->clear();
81813     } catch (std::out_of_range& e) {
81814       {
81815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81816       };
81817     } catch (std::exception& e) {
81818       {
81819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81820       };
81821     } catch (...) {
81822       {
81823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81824       };
81825     }
81826   }
81827 }
81828
81829
81830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
81831   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81832   Dali::Actor *arg2 = 0 ;
81833
81834   arg1 = (std::vector< Dali::Actor > *)jarg1;
81835   arg2 = (Dali::Actor *)jarg2;
81836   if (!arg2) {
81837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
81838     return ;
81839   }
81840   {
81841     try {
81842       (arg1)->push_back((Dali::Actor const &)*arg2);
81843     } catch (std::out_of_range& e) {
81844       {
81845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81846       };
81847     } catch (std::exception& e) {
81848       {
81849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81850       };
81851     } catch (...) {
81852       {
81853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81854       };
81855     }
81856   }
81857 }
81858
81859
81860 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
81861   unsigned long jresult ;
81862   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81863   std::vector< Dali::Actor >::size_type result;
81864
81865   arg1 = (std::vector< Dali::Actor > *)jarg1;
81866   {
81867     try {
81868       result = ((std::vector< Dali::Actor > const *)arg1)->size();
81869     } catch (std::out_of_range& e) {
81870       {
81871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81872       };
81873     } catch (std::exception& e) {
81874       {
81875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81876       };
81877     } catch (...) {
81878       {
81879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81880       };
81881     }
81882   }
81883   jresult = (unsigned long)result;
81884   return jresult;
81885 }
81886
81887
81888 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
81889   unsigned long jresult ;
81890   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81891   std::vector< Dali::Actor >::size_type result;
81892
81893   arg1 = (std::vector< Dali::Actor > *)jarg1;
81894   {
81895     try {
81896       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
81897     } catch (std::out_of_range& e) {
81898       {
81899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81900       };
81901     } catch (std::exception& e) {
81902       {
81903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81904       };
81905     } catch (...) {
81906       {
81907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81908       };
81909     }
81910   }
81911   jresult = (unsigned long)result;
81912   return jresult;
81913 }
81914
81915
81916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
81917   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81918   std::vector< Dali::Actor >::size_type arg2 ;
81919
81920   arg1 = (std::vector< Dali::Actor > *)jarg1;
81921   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
81922   {
81923     try {
81924       (arg1)->reserve(arg2);
81925     } catch (std::out_of_range& e) {
81926       {
81927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81928       };
81929     } catch (std::exception& e) {
81930       {
81931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81932       };
81933     } catch (...) {
81934       {
81935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81936       };
81937     }
81938   }
81939 }
81940
81941
81942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
81943   void * jresult ;
81944   std::vector< Dali::Actor > *result = 0 ;
81945
81946   {
81947     try {
81948       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
81949     } catch (std::out_of_range& e) {
81950       {
81951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81952       };
81953     } catch (std::exception& e) {
81954       {
81955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81956       };
81957     } catch (...) {
81958       {
81959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81960       };
81961     }
81962   }
81963   jresult = (void *)result;
81964   return jresult;
81965 }
81966
81967
81968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
81969   void * jresult ;
81970   std::vector< Dali::Actor > *arg1 = 0 ;
81971   std::vector< Dali::Actor > *result = 0 ;
81972
81973   arg1 = (std::vector< Dali::Actor > *)jarg1;
81974   if (!arg1) {
81975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
81976     return 0;
81977   }
81978   {
81979     try {
81980       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
81981     } catch (std::out_of_range& e) {
81982       {
81983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81984       };
81985     } catch (std::exception& e) {
81986       {
81987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81988       };
81989     } catch (...) {
81990       {
81991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81992       };
81993     }
81994   }
81995   jresult = (void *)result;
81996   return jresult;
81997 }
81998
81999
82000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
82001   void * jresult ;
82002   int arg1 ;
82003   std::vector< Dali::Actor > *result = 0 ;
82004
82005   arg1 = (int)jarg1;
82006   {
82007     try {
82008       try {
82009         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
82010       }
82011       catch(std::out_of_range &_e) {
82012         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82013         return 0;
82014       }
82015
82016     } catch (std::out_of_range& e) {
82017       {
82018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82019       };
82020     } catch (std::exception& e) {
82021       {
82022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82023       };
82024     } catch (...) {
82025       {
82026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82027       };
82028     }
82029   }
82030   jresult = (void *)result;
82031   return jresult;
82032 }
82033
82034
82035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
82036   void * jresult ;
82037   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82038   int arg2 ;
82039   Dali::Actor result;
82040
82041   arg1 = (std::vector< Dali::Actor > *)jarg1;
82042   arg2 = (int)jarg2;
82043   {
82044     try {
82045       try {
82046         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
82047       }
82048       catch(std::out_of_range &_e) {
82049         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82050         return 0;
82051       }
82052
82053     } catch (std::out_of_range& e) {
82054       {
82055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82056       };
82057     } catch (std::exception& e) {
82058       {
82059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82060       };
82061     } catch (...) {
82062       {
82063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82064       };
82065     }
82066   }
82067   jresult = new Dali::Actor((const Dali::Actor &)result);
82068   return jresult;
82069 }
82070
82071
82072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
82073   void * jresult ;
82074   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82075   int arg2 ;
82076   Dali::Actor *result = 0 ;
82077
82078   arg1 = (std::vector< Dali::Actor > *)jarg1;
82079   arg2 = (int)jarg2;
82080   {
82081     try {
82082       try {
82083         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
82084       }
82085       catch(std::out_of_range &_e) {
82086         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82087         return 0;
82088       }
82089
82090     } catch (std::out_of_range& e) {
82091       {
82092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82093       };
82094     } catch (std::exception& e) {
82095       {
82096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82097       };
82098     } catch (...) {
82099       {
82100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82101       };
82102     }
82103   }
82104   jresult = (void *)result;
82105   return jresult;
82106 }
82107
82108
82109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
82110   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82111   int arg2 ;
82112   Dali::Actor *arg3 = 0 ;
82113
82114   arg1 = (std::vector< Dali::Actor > *)jarg1;
82115   arg2 = (int)jarg2;
82116   arg3 = (Dali::Actor *)jarg3;
82117   if (!arg3) {
82118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82119     return ;
82120   }
82121   {
82122     try {
82123       try {
82124         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
82125       }
82126       catch(std::out_of_range &_e) {
82127         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82128         return ;
82129       }
82130
82131     } catch (std::out_of_range& e) {
82132       {
82133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82134       };
82135     } catch (std::exception& e) {
82136       {
82137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82138       };
82139     } catch (...) {
82140       {
82141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82142       };
82143     }
82144   }
82145 }
82146
82147
82148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
82149   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82150   std::vector< Dali::Actor > *arg2 = 0 ;
82151
82152   arg1 = (std::vector< Dali::Actor > *)jarg1;
82153   arg2 = (std::vector< Dali::Actor > *)jarg2;
82154   if (!arg2) {
82155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82156     return ;
82157   }
82158   {
82159     try {
82160       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
82161     } catch (std::out_of_range& e) {
82162       {
82163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82164       };
82165     } catch (std::exception& e) {
82166       {
82167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82168       };
82169     } catch (...) {
82170       {
82171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82172       };
82173     }
82174   }
82175 }
82176
82177
82178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
82179   void * jresult ;
82180   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82181   int arg2 ;
82182   int arg3 ;
82183   std::vector< Dali::Actor > *result = 0 ;
82184
82185   arg1 = (std::vector< Dali::Actor > *)jarg1;
82186   arg2 = (int)jarg2;
82187   arg3 = (int)jarg3;
82188   {
82189     try {
82190       try {
82191         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
82192       }
82193       catch(std::out_of_range &_e) {
82194         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82195         return 0;
82196       }
82197       catch(std::invalid_argument &_e) {
82198         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82199         return 0;
82200       }
82201
82202     } catch (std::out_of_range& e) {
82203       {
82204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82205       };
82206     } catch (std::exception& e) {
82207       {
82208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82209       };
82210     } catch (...) {
82211       {
82212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82213       };
82214     }
82215   }
82216   jresult = (void *)result;
82217   return jresult;
82218 }
82219
82220
82221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
82222   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82223   int arg2 ;
82224   Dali::Actor *arg3 = 0 ;
82225
82226   arg1 = (std::vector< Dali::Actor > *)jarg1;
82227   arg2 = (int)jarg2;
82228   arg3 = (Dali::Actor *)jarg3;
82229   if (!arg3) {
82230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82231     return ;
82232   }
82233   {
82234     try {
82235       try {
82236         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
82237       }
82238       catch(std::out_of_range &_e) {
82239         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82240         return ;
82241       }
82242
82243     } catch (std::out_of_range& e) {
82244       {
82245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82246       };
82247     } catch (std::exception& e) {
82248       {
82249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82250       };
82251     } catch (...) {
82252       {
82253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82254       };
82255     }
82256   }
82257 }
82258
82259
82260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
82261   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82262   int arg2 ;
82263   std::vector< Dali::Actor > *arg3 = 0 ;
82264
82265   arg1 = (std::vector< Dali::Actor > *)jarg1;
82266   arg2 = (int)jarg2;
82267   arg3 = (std::vector< Dali::Actor > *)jarg3;
82268   if (!arg3) {
82269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82270     return ;
82271   }
82272   {
82273     try {
82274       try {
82275         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
82276       }
82277       catch(std::out_of_range &_e) {
82278         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82279         return ;
82280       }
82281
82282     } catch (std::out_of_range& e) {
82283       {
82284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82285       };
82286     } catch (std::exception& e) {
82287       {
82288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82289       };
82290     } catch (...) {
82291       {
82292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82293       };
82294     }
82295   }
82296 }
82297
82298
82299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
82300   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82301   int arg2 ;
82302
82303   arg1 = (std::vector< Dali::Actor > *)jarg1;
82304   arg2 = (int)jarg2;
82305   {
82306     try {
82307       try {
82308         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
82309       }
82310       catch(std::out_of_range &_e) {
82311         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82312         return ;
82313       }
82314
82315     } catch (std::out_of_range& e) {
82316       {
82317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82318       };
82319     } catch (std::exception& e) {
82320       {
82321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82322       };
82323     } catch (...) {
82324       {
82325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82326       };
82327     }
82328   }
82329 }
82330
82331
82332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
82333   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82334   int arg2 ;
82335   int arg3 ;
82336
82337   arg1 = (std::vector< Dali::Actor > *)jarg1;
82338   arg2 = (int)jarg2;
82339   arg3 = (int)jarg3;
82340   {
82341     try {
82342       try {
82343         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
82344       }
82345       catch(std::out_of_range &_e) {
82346         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82347         return ;
82348       }
82349       catch(std::invalid_argument &_e) {
82350         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82351         return ;
82352       }
82353
82354     } catch (std::out_of_range& e) {
82355       {
82356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82357       };
82358     } catch (std::exception& e) {
82359       {
82360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82361       };
82362     } catch (...) {
82363       {
82364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82365       };
82366     }
82367   }
82368 }
82369
82370
82371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
82372   void * jresult ;
82373   Dali::Actor *arg1 = 0 ;
82374   int arg2 ;
82375   std::vector< Dali::Actor > *result = 0 ;
82376
82377   arg1 = (Dali::Actor *)jarg1;
82378   if (!arg1) {
82379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82380     return 0;
82381   }
82382   arg2 = (int)jarg2;
82383   {
82384     try {
82385       try {
82386         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
82387       }
82388       catch(std::out_of_range &_e) {
82389         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82390         return 0;
82391       }
82392
82393     } catch (std::out_of_range& e) {
82394       {
82395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82396       };
82397     } catch (std::exception& e) {
82398       {
82399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82400       };
82401     } catch (...) {
82402       {
82403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82404       };
82405     }
82406   }
82407   jresult = (void *)result;
82408   return jresult;
82409 }
82410
82411
82412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
82413   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82414
82415   arg1 = (std::vector< Dali::Actor > *)jarg1;
82416   {
82417     try {
82418       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
82419     } catch (std::out_of_range& e) {
82420       {
82421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82422       };
82423     } catch (std::exception& e) {
82424       {
82425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82426       };
82427     } catch (...) {
82428       {
82429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82430       };
82431     }
82432   }
82433 }
82434
82435
82436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
82437   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82438   int arg2 ;
82439   int arg3 ;
82440
82441   arg1 = (std::vector< Dali::Actor > *)jarg1;
82442   arg2 = (int)jarg2;
82443   arg3 = (int)jarg3;
82444   {
82445     try {
82446       try {
82447         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
82448       }
82449       catch(std::out_of_range &_e) {
82450         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82451         return ;
82452       }
82453       catch(std::invalid_argument &_e) {
82454         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82455         return ;
82456       }
82457
82458     } catch (std::out_of_range& e) {
82459       {
82460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82461       };
82462     } catch (std::exception& e) {
82463       {
82464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82465       };
82466     } catch (...) {
82467       {
82468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82469       };
82470     }
82471   }
82472 }
82473
82474
82475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
82476   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82477   int arg2 ;
82478   std::vector< Dali::Actor > *arg3 = 0 ;
82479
82480   arg1 = (std::vector< Dali::Actor > *)jarg1;
82481   arg2 = (int)jarg2;
82482   arg3 = (std::vector< Dali::Actor > *)jarg3;
82483   if (!arg3) {
82484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82485     return ;
82486   }
82487   {
82488     try {
82489       try {
82490         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
82491       }
82492       catch(std::out_of_range &_e) {
82493         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82494         return ;
82495       }
82496
82497     } catch (std::out_of_range& e) {
82498       {
82499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82500       };
82501     } catch (std::exception& e) {
82502       {
82503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82504       };
82505     } catch (...) {
82506       {
82507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82508       };
82509     }
82510   }
82511 }
82512
82513
82514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
82515   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82516
82517   arg1 = (std::vector< Dali::Actor > *)jarg1;
82518   {
82519     try {
82520       delete arg1;
82521     } catch (std::out_of_range& e) {
82522       {
82523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82524       };
82525     } catch (std::exception& e) {
82526       {
82527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82528       };
82529     } catch (...) {
82530       {
82531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82532       };
82533     }
82534   }
82535 }
82536
82537
82538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
82539   unsigned int jresult ;
82540   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82541   bool result;
82542
82543   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82544   {
82545     try {
82546       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
82547     } catch (std::out_of_range& e) {
82548       {
82549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82550       };
82551     } catch (std::exception& e) {
82552       {
82553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82554       };
82555     } catch (...) {
82556       {
82557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82558       };
82559     }
82560   }
82561   jresult = result;
82562   return jresult;
82563 }
82564
82565
82566 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
82567   unsigned long jresult ;
82568   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82569   std::size_t result;
82570
82571   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82572   {
82573     try {
82574       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
82575     } catch (std::out_of_range& e) {
82576       {
82577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82578       };
82579     } catch (std::exception& e) {
82580       {
82581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82582       };
82583     } catch (...) {
82584       {
82585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82586       };
82587     }
82588   }
82589   jresult = (unsigned long)result;
82590   return jresult;
82591 }
82592
82593
82594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
82595   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82596   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
82597
82598   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82599   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
82600   {
82601     try {
82602       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
82603     } catch (std::out_of_range& e) {
82604       {
82605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82606       };
82607     } catch (std::exception& e) {
82608       {
82609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82610       };
82611     } catch (...) {
82612       {
82613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82614       };
82615     }
82616   }
82617 }
82618
82619
82620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
82621   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82622   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
82623
82624   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82625   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
82626   {
82627     try {
82628       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
82629     } catch (std::out_of_range& e) {
82630       {
82631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82632       };
82633     } catch (std::exception& e) {
82634       {
82635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82636       };
82637     } catch (...) {
82638       {
82639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82640       };
82641     }
82642   }
82643 }
82644
82645
82646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
82647   unsigned int jresult ;
82648   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82649   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
82650   bool result;
82651
82652   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82653   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
82654   if (!arg2) {
82655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
82656     return 0;
82657   }
82658   {
82659     try {
82660       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
82661     } catch (std::out_of_range& e) {
82662       {
82663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82664       };
82665     } catch (std::exception& e) {
82666       {
82667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82668       };
82669     } catch (...) {
82670       {
82671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82672       };
82673     }
82674   }
82675   jresult = result;
82676   return jresult;
82677 }
82678
82679
82680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
82681   void * jresult ;
82682   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
82683
82684   {
82685     try {
82686       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
82687     } catch (std::out_of_range& e) {
82688       {
82689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82690       };
82691     } catch (std::exception& e) {
82692       {
82693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82694       };
82695     } catch (...) {
82696       {
82697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82698       };
82699     }
82700   }
82701   jresult = (void *)result;
82702   return jresult;
82703 }
82704
82705
82706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
82707   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82708
82709   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82710   {
82711     try {
82712       delete arg1;
82713     } catch (std::out_of_range& e) {
82714       {
82715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82716       };
82717     } catch (std::exception& e) {
82718       {
82719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82720       };
82721     } catch (...) {
82722       {
82723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82724       };
82725     }
82726   }
82727 }
82728
82729
82730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
82731   unsigned int jresult ;
82732   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82733   bool result;
82734
82735   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82736   {
82737     try {
82738       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);
82739     } catch (std::out_of_range& e) {
82740       {
82741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82742       };
82743     } catch (std::exception& e) {
82744       {
82745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82746       };
82747     } catch (...) {
82748       {
82749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82750       };
82751     }
82752   }
82753   jresult = result;
82754   return jresult;
82755 }
82756
82757
82758 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
82759   unsigned long jresult ;
82760   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82761   std::size_t result;
82762
82763   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82764   {
82765     try {
82766       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);
82767     } catch (std::out_of_range& e) {
82768       {
82769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82770       };
82771     } catch (std::exception& e) {
82772       {
82773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82774       };
82775     } catch (...) {
82776       {
82777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82778       };
82779     }
82780   }
82781   jresult = (unsigned long)result;
82782   return jresult;
82783 }
82784
82785
82786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
82787   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82788   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
82789
82790   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82791   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
82792   {
82793     try {
82794       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
82795     } catch (std::out_of_range& e) {
82796       {
82797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82798       };
82799     } catch (std::exception& e) {
82800       {
82801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82802       };
82803     } catch (...) {
82804       {
82805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82806       };
82807     }
82808   }
82809 }
82810
82811
82812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
82813   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82814   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
82815
82816   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82817   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
82818   {
82819     try {
82820       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
82821     } catch (std::out_of_range& e) {
82822       {
82823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82824       };
82825     } catch (std::exception& e) {
82826       {
82827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82828       };
82829     } catch (...) {
82830       {
82831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82832       };
82833     }
82834   }
82835 }
82836
82837
82838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
82839   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82840   Dali::Actor arg2 ;
82841   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
82842   Dali::Actor *argp2 ;
82843
82844   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82845   argp2 = (Dali::Actor *)jarg2;
82846   if (!argp2) {
82847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82848     return ;
82849   }
82850   arg2 = *argp2;
82851   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
82852   {
82853     try {
82854       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
82855     } catch (std::out_of_range& e) {
82856       {
82857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82858       };
82859     } catch (std::exception& e) {
82860       {
82861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82862       };
82863     } catch (...) {
82864       {
82865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82866       };
82867     }
82868   }
82869 }
82870
82871
82872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
82873   void * jresult ;
82874   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
82875
82876   {
82877     try {
82878       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
82879     } catch (std::out_of_range& e) {
82880       {
82881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82882       };
82883     } catch (std::exception& e) {
82884       {
82885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82886       };
82887     } catch (...) {
82888       {
82889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82890       };
82891     }
82892   }
82893   jresult = (void *)result;
82894   return jresult;
82895 }
82896
82897
82898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
82899   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82900
82901   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82902   {
82903     try {
82904       delete arg1;
82905     } catch (std::out_of_range& e) {
82906       {
82907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82908       };
82909     } catch (std::exception& e) {
82910       {
82911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82912       };
82913     } catch (...) {
82914       {
82915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82916       };
82917     }
82918   }
82919 }
82920
82921
82922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
82923   unsigned int jresult ;
82924   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
82925   bool result;
82926
82927   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
82928   {
82929     try {
82930       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
82931     } catch (std::out_of_range& e) {
82932       {
82933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82934       };
82935     } catch (std::exception& e) {
82936       {
82937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82938       };
82939     } catch (...) {
82940       {
82941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82942       };
82943     }
82944   }
82945   jresult = result;
82946   return jresult;
82947 }
82948
82949
82950 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
82951   unsigned long jresult ;
82952   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
82953   std::size_t result;
82954
82955   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
82956   {
82957     try {
82958       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
82959     } catch (std::out_of_range& e) {
82960       {
82961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82962       };
82963     } catch (std::exception& e) {
82964       {
82965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82966       };
82967     } catch (...) {
82968       {
82969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82970       };
82971     }
82972   }
82973   jresult = (unsigned long)result;
82974   return jresult;
82975 }
82976
82977
82978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
82979   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
82980   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
82981
82982   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
82983   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
82984   {
82985     try {
82986       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
82987     } catch (std::out_of_range& e) {
82988       {
82989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82990       };
82991     } catch (std::exception& e) {
82992       {
82993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82994       };
82995     } catch (...) {
82996       {
82997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82998       };
82999     }
83000   }
83001 }
83002
83003
83004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
83005   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83006   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
83007
83008   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83009   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
83010   {
83011     try {
83012       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
83013     } catch (std::out_of_range& e) {
83014       {
83015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83016       };
83017     } catch (std::exception& e) {
83018       {
83019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83020       };
83021     } catch (...) {
83022       {
83023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83024       };
83025     }
83026   }
83027 }
83028
83029
83030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
83031   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83032   Dali::Actor arg2 ;
83033   Dali::Actor arg3 ;
83034   Dali::Actor *argp2 ;
83035   Dali::Actor *argp3 ;
83036
83037   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83038   argp2 = (Dali::Actor *)jarg2;
83039   if (!argp2) {
83040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83041     return ;
83042   }
83043   arg2 = *argp2;
83044   argp3 = (Dali::Actor *)jarg3;
83045   if (!argp3) {
83046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83047     return ;
83048   }
83049   arg3 = *argp3;
83050   {
83051     try {
83052       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
83053     } catch (std::out_of_range& e) {
83054       {
83055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83056       };
83057     } catch (std::exception& e) {
83058       {
83059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83060       };
83061     } catch (...) {
83062       {
83063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83064       };
83065     }
83066   }
83067 }
83068
83069
83070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
83071   void * jresult ;
83072   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
83073
83074   {
83075     try {
83076       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
83077     } catch (std::out_of_range& e) {
83078       {
83079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83080       };
83081     } catch (std::exception& e) {
83082       {
83083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83084       };
83085     } catch (...) {
83086       {
83087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83088       };
83089     }
83090   }
83091   jresult = (void *)result;
83092   return jresult;
83093 }
83094
83095
83096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
83097   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83098
83099   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83100   {
83101     try {
83102       delete arg1;
83103     } catch (std::out_of_range& e) {
83104       {
83105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83106       };
83107     } catch (std::exception& e) {
83108       {
83109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83110       };
83111     } catch (...) {
83112       {
83113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83114       };
83115     }
83116   }
83117 }
83118
83119
83120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
83121   unsigned int jresult ;
83122   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83123   bool result;
83124
83125   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83126   {
83127     try {
83128       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
83129     } catch (std::out_of_range& e) {
83130       {
83131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83132       };
83133     } catch (std::exception& e) {
83134       {
83135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83136       };
83137     } catch (...) {
83138       {
83139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83140       };
83141     }
83142   }
83143   jresult = result;
83144   return jresult;
83145 }
83146
83147
83148 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
83149   unsigned long jresult ;
83150   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83151   std::size_t result;
83152
83153   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83154   {
83155     try {
83156       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
83157     } catch (std::out_of_range& e) {
83158       {
83159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83160       };
83161     } catch (std::exception& e) {
83162       {
83163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83164       };
83165     } catch (...) {
83166       {
83167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83168       };
83169     }
83170   }
83171   jresult = (unsigned long)result;
83172   return jresult;
83173 }
83174
83175
83176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
83177   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83178   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
83179
83180   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83181   arg2 = (void (*)(Dali::Actor,bool))jarg2;
83182   {
83183     try {
83184       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
83185     } catch (std::out_of_range& e) {
83186       {
83187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83188       };
83189     } catch (std::exception& e) {
83190       {
83191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83192       };
83193     } catch (...) {
83194       {
83195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83196       };
83197     }
83198   }
83199 }
83200
83201
83202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
83203   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83204   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
83205
83206   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83207   arg2 = (void (*)(Dali::Actor,bool))jarg2;
83208   {
83209     try {
83210       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
83211     } catch (std::out_of_range& e) {
83212       {
83213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83214       };
83215     } catch (std::exception& e) {
83216       {
83217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83218       };
83219     } catch (...) {
83220       {
83221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83222       };
83223     }
83224   }
83225 }
83226
83227
83228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
83229   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83230   Dali::Actor arg2 ;
83231   bool arg3 ;
83232   Dali::Actor *argp2 ;
83233
83234   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83235   argp2 = (Dali::Actor *)jarg2;
83236   if (!argp2) {
83237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83238     return ;
83239   }
83240   arg2 = *argp2;
83241   arg3 = jarg3 ? true : false;
83242   {
83243     try {
83244       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
83245     } catch (std::out_of_range& e) {
83246       {
83247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83248       };
83249     } catch (std::exception& e) {
83250       {
83251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83252       };
83253     } catch (...) {
83254       {
83255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83256       };
83257     }
83258   }
83259 }
83260
83261
83262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
83263   void * jresult ;
83264   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
83265
83266   {
83267     try {
83268       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
83269     } catch (std::out_of_range& e) {
83270       {
83271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83272       };
83273     } catch (std::exception& e) {
83274       {
83275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83276       };
83277     } catch (...) {
83278       {
83279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83280       };
83281     }
83282   }
83283   jresult = (void *)result;
83284   return jresult;
83285 }
83286
83287
83288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
83289   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83290
83291   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83292   {
83293     try {
83294       delete arg1;
83295     } catch (std::out_of_range& e) {
83296       {
83297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83298       };
83299     } catch (std::exception& e) {
83300       {
83301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83302       };
83303     } catch (...) {
83304       {
83305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83306       };
83307     }
83308   }
83309 }
83310
83311
83312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
83313   unsigned int jresult ;
83314   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83315   bool result;
83316
83317   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83318   {
83319     try {
83320       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);
83321     } catch (std::out_of_range& e) {
83322       {
83323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83324       };
83325     } catch (std::exception& e) {
83326       {
83327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83328       };
83329     } catch (...) {
83330       {
83331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83332       };
83333     }
83334   }
83335   jresult = result;
83336   return jresult;
83337 }
83338
83339
83340 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
83341   unsigned long jresult ;
83342   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83343   std::size_t result;
83344
83345   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83346   {
83347     try {
83348       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);
83349     } catch (std::out_of_range& e) {
83350       {
83351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83352       };
83353     } catch (std::exception& e) {
83354       {
83355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83356       };
83357     } catch (...) {
83358       {
83359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83360       };
83361     }
83362   }
83363   jresult = (unsigned long)result;
83364   return jresult;
83365 }
83366
83367
83368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
83369   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83370   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
83371
83372   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83373   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
83374   {
83375     try {
83376       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
83377     } catch (std::out_of_range& e) {
83378       {
83379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83380       };
83381     } catch (std::exception& e) {
83382       {
83383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83384       };
83385     } catch (...) {
83386       {
83387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83388       };
83389     }
83390   }
83391 }
83392
83393
83394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
83395   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83396   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
83397
83398   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83399   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
83400   {
83401     try {
83402       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
83403     } catch (std::out_of_range& e) {
83404       {
83405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83406       };
83407     } catch (std::exception& e) {
83408       {
83409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83410       };
83411     } catch (...) {
83412       {
83413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83414       };
83415     }
83416   }
83417 }
83418
83419
83420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
83421   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83422   Dali::Toolkit::StyleManager arg2 ;
83423   Dali::StyleChange::Type arg3 ;
83424   Dali::Toolkit::StyleManager *argp2 ;
83425
83426   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83427   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
83428   if (!argp2) {
83429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
83430     return ;
83431   }
83432   arg2 = *argp2;
83433   arg3 = (Dali::StyleChange::Type)jarg3;
83434   {
83435     try {
83436       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
83437     } catch (std::out_of_range& e) {
83438       {
83439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83440       };
83441     } catch (std::exception& e) {
83442       {
83443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83444       };
83445     } catch (...) {
83446       {
83447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83448       };
83449     }
83450   }
83451 }
83452
83453
83454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
83455   void * jresult ;
83456   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
83457
83458   {
83459     try {
83460       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
83461     } catch (std::out_of_range& e) {
83462       {
83463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83464       };
83465     } catch (std::exception& e) {
83466       {
83467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83468       };
83469     } catch (...) {
83470       {
83471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83472       };
83473     }
83474   }
83475   jresult = (void *)result;
83476   return jresult;
83477 }
83478
83479
83480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
83481   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83482
83483   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83484   {
83485     try {
83486       delete arg1;
83487     } catch (std::out_of_range& e) {
83488       {
83489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83490       };
83491     } catch (std::exception& e) {
83492       {
83493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83494       };
83495     } catch (...) {
83496       {
83497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83498       };
83499     }
83500   }
83501 }
83502
83503
83504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
83505   unsigned int jresult ;
83506   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83507   bool result;
83508
83509   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83510   {
83511     try {
83512       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
83513     } catch (std::out_of_range& e) {
83514       {
83515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83516       };
83517     } catch (std::exception& e) {
83518       {
83519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83520       };
83521     } catch (...) {
83522       {
83523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83524       };
83525     }
83526   }
83527   jresult = result;
83528   return jresult;
83529 }
83530
83531
83532 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
83533   unsigned long jresult ;
83534   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83535   std::size_t result;
83536
83537   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83538   {
83539     try {
83540       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
83541     } catch (std::out_of_range& e) {
83542       {
83543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83544       };
83545     } catch (std::exception& e) {
83546       {
83547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83548       };
83549     } catch (...) {
83550       {
83551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83552       };
83553     }
83554   }
83555   jresult = (unsigned long)result;
83556   return jresult;
83557 }
83558
83559
83560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
83561   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83562   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
83563
83564   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83565   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
83566   {
83567     try {
83568       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
83569     } catch (std::out_of_range& e) {
83570       {
83571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83572       };
83573     } catch (std::exception& e) {
83574       {
83575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83576       };
83577     } catch (...) {
83578       {
83579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83580       };
83581     }
83582   }
83583 }
83584
83585
83586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
83587   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83588   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
83589
83590   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83591   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
83592   {
83593     try {
83594       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
83595     } catch (std::out_of_range& e) {
83596       {
83597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83598       };
83599     } catch (std::exception& e) {
83600       {
83601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83602       };
83603     } catch (...) {
83604       {
83605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83606       };
83607     }
83608   }
83609 }
83610
83611
83612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
83613   unsigned int jresult ;
83614   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83615   Dali::Toolkit::Button arg2 ;
83616   Dali::Toolkit::Button *argp2 ;
83617   bool result;
83618
83619   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83620   argp2 = (Dali::Toolkit::Button *)jarg2;
83621   if (!argp2) {
83622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
83623     return 0;
83624   }
83625   arg2 = *argp2;
83626   {
83627     try {
83628       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
83629     } catch (std::out_of_range& e) {
83630       {
83631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83632       };
83633     } catch (std::exception& e) {
83634       {
83635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83636       };
83637     } catch (...) {
83638       {
83639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83640       };
83641     }
83642   }
83643   jresult = result;
83644   return jresult;
83645 }
83646
83647
83648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
83649   void * jresult ;
83650   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
83651
83652   {
83653     try {
83654       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
83655     } catch (std::out_of_range& e) {
83656       {
83657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83658       };
83659     } catch (std::exception& e) {
83660       {
83661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83662       };
83663     } catch (...) {
83664       {
83665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83666       };
83667     }
83668   }
83669   jresult = (void *)result;
83670   return jresult;
83671 }
83672
83673
83674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
83675   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83676
83677   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83678   {
83679     try {
83680       delete arg1;
83681     } catch (std::out_of_range& e) {
83682       {
83683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83684       };
83685     } catch (std::exception& e) {
83686       {
83687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83688       };
83689     } catch (...) {
83690       {
83691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83692       };
83693     }
83694   }
83695 }
83696
83697
83698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
83699   unsigned int jresult ;
83700   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83701   bool result;
83702
83703   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83704   {
83705     try {
83706       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
83707     } catch (std::out_of_range& e) {
83708       {
83709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83710       };
83711     } catch (std::exception& e) {
83712       {
83713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83714       };
83715     } catch (...) {
83716       {
83717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83718       };
83719     }
83720   }
83721   jresult = result;
83722   return jresult;
83723 }
83724
83725
83726 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
83727   unsigned long jresult ;
83728   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83729   std::size_t result;
83730
83731   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83732   {
83733     try {
83734       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
83735     } catch (std::out_of_range& e) {
83736       {
83737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83738       };
83739     } catch (std::exception& e) {
83740       {
83741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83742       };
83743     } catch (...) {
83744       {
83745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83746       };
83747     }
83748   }
83749   jresult = (unsigned long)result;
83750   return jresult;
83751 }
83752
83753
83754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
83755   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83756   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
83757
83758   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83759   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
83760   {
83761     try {
83762       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
83763     } catch (std::out_of_range& e) {
83764       {
83765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83766       };
83767     } catch (std::exception& e) {
83768       {
83769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83770       };
83771     } catch (...) {
83772       {
83773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83774       };
83775     }
83776   }
83777 }
83778
83779
83780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
83781   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83782   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
83783
83784   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83785   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
83786   {
83787     try {
83788       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
83789     } catch (std::out_of_range& e) {
83790       {
83791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83792       };
83793     } catch (std::exception& e) {
83794       {
83795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83796       };
83797     } catch (...) {
83798       {
83799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83800       };
83801     }
83802   }
83803 }
83804
83805
83806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
83807   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83808   Dali::Toolkit::GaussianBlurView arg2 ;
83809   Dali::Toolkit::GaussianBlurView *argp2 ;
83810
83811   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83812   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83813   if (!argp2) {
83814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
83815     return ;
83816   }
83817   arg2 = *argp2;
83818   {
83819     try {
83820       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
83821     } catch (std::out_of_range& e) {
83822       {
83823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83824       };
83825     } catch (std::exception& e) {
83826       {
83827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83828       };
83829     } catch (...) {
83830       {
83831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83832       };
83833     }
83834   }
83835 }
83836
83837
83838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
83839   void * jresult ;
83840   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
83841
83842   {
83843     try {
83844       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
83845     } catch (std::out_of_range& e) {
83846       {
83847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83848       };
83849     } catch (std::exception& e) {
83850       {
83851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83852       };
83853     } catch (...) {
83854       {
83855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83856       };
83857     }
83858   }
83859   jresult = (void *)result;
83860   return jresult;
83861 }
83862
83863
83864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
83865   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83866
83867   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83868   {
83869     try {
83870       delete arg1;
83871     } catch (std::out_of_range& e) {
83872       {
83873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83874       };
83875     } catch (std::exception& e) {
83876       {
83877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83878       };
83879     } catch (...) {
83880       {
83881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83882       };
83883     }
83884   }
83885 }
83886
83887
83888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
83889   unsigned int jresult ;
83890   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83891   bool result;
83892
83893   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83894   {
83895     try {
83896       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);
83897     } catch (std::out_of_range& e) {
83898       {
83899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83900       };
83901     } catch (std::exception& e) {
83902       {
83903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83904       };
83905     } catch (...) {
83906       {
83907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83908       };
83909     }
83910   }
83911   jresult = result;
83912   return jresult;
83913 }
83914
83915
83916 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
83917   unsigned long jresult ;
83918   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83919   std::size_t result;
83920
83921   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83922   {
83923     try {
83924       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);
83925     } catch (std::out_of_range& e) {
83926       {
83927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83928       };
83929     } catch (std::exception& e) {
83930       {
83931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83932       };
83933     } catch (...) {
83934       {
83935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83936       };
83937     }
83938   }
83939   jresult = (unsigned long)result;
83940   return jresult;
83941 }
83942
83943
83944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
83945   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83946   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
83947
83948   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83949   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
83950   {
83951     try {
83952       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
83953     } catch (std::out_of_range& e) {
83954       {
83955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83956       };
83957     } catch (std::exception& e) {
83958       {
83959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83960       };
83961     } catch (...) {
83962       {
83963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83964       };
83965     }
83966   }
83967 }
83968
83969
83970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
83971   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83972   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
83973
83974   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83975   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
83976   {
83977     try {
83978       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
83979     } catch (std::out_of_range& e) {
83980       {
83981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83982       };
83983     } catch (std::exception& e) {
83984       {
83985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83986       };
83987     } catch (...) {
83988       {
83989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83990       };
83991     }
83992   }
83993 }
83994
83995
83996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
83997   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83998   Dali::Toolkit::PageTurnView arg2 ;
83999   unsigned int arg3 ;
84000   bool arg4 ;
84001   Dali::Toolkit::PageTurnView *argp2 ;
84002
84003   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84004   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
84005   if (!argp2) {
84006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
84007     return ;
84008   }
84009   arg2 = *argp2;
84010   arg3 = (unsigned int)jarg3;
84011   arg4 = jarg4 ? true : false;
84012   {
84013     try {
84014       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
84015     } catch (std::out_of_range& e) {
84016       {
84017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84018       };
84019     } catch (std::exception& e) {
84020       {
84021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84022       };
84023     } catch (...) {
84024       {
84025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84026       };
84027     }
84028   }
84029 }
84030
84031
84032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
84033   void * jresult ;
84034   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
84035
84036   {
84037     try {
84038       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
84039     } catch (std::out_of_range& e) {
84040       {
84041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84042       };
84043     } catch (std::exception& e) {
84044       {
84045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84046       };
84047     } catch (...) {
84048       {
84049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84050       };
84051     }
84052   }
84053   jresult = (void *)result;
84054   return jresult;
84055 }
84056
84057
84058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
84059   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84060
84061   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84062   {
84063     try {
84064       delete arg1;
84065     } catch (std::out_of_range& e) {
84066       {
84067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84068       };
84069     } catch (std::exception& e) {
84070       {
84071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84072       };
84073     } catch (...) {
84074       {
84075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84076       };
84077     }
84078   }
84079 }
84080
84081
84082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
84083   unsigned int jresult ;
84084   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84085   bool result;
84086
84087   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84088   {
84089     try {
84090       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
84091     } catch (std::out_of_range& e) {
84092       {
84093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84094       };
84095     } catch (std::exception& e) {
84096       {
84097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84098       };
84099     } catch (...) {
84100       {
84101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84102       };
84103     }
84104   }
84105   jresult = result;
84106   return jresult;
84107 }
84108
84109
84110 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
84111   unsigned long jresult ;
84112   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84113   std::size_t result;
84114
84115   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84116   {
84117     try {
84118       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
84119     } catch (std::out_of_range& e) {
84120       {
84121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84122       };
84123     } catch (std::exception& e) {
84124       {
84125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84126       };
84127     } catch (...) {
84128       {
84129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84130       };
84131     }
84132   }
84133   jresult = (unsigned long)result;
84134   return jresult;
84135 }
84136
84137
84138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
84139   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84140   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
84141
84142   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84143   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
84144   {
84145     try {
84146       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
84147     } catch (std::out_of_range& e) {
84148       {
84149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84150       };
84151     } catch (std::exception& e) {
84152       {
84153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84154       };
84155     } catch (...) {
84156       {
84157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84158       };
84159     }
84160   }
84161 }
84162
84163
84164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
84165   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84166   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
84167
84168   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84169   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
84170   {
84171     try {
84172       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
84173     } catch (std::out_of_range& e) {
84174       {
84175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84176       };
84177     } catch (std::exception& e) {
84178       {
84179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84180       };
84181     } catch (...) {
84182       {
84183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84184       };
84185     }
84186   }
84187 }
84188
84189
84190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
84191   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84192   Dali::Toolkit::PageTurnView arg2 ;
84193   Dali::Toolkit::PageTurnView *argp2 ;
84194
84195   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84196   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
84197   if (!argp2) {
84198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
84199     return ;
84200   }
84201   arg2 = *argp2;
84202   {
84203     try {
84204       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
84205     } catch (std::out_of_range& e) {
84206       {
84207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84208       };
84209     } catch (std::exception& e) {
84210       {
84211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84212       };
84213     } catch (...) {
84214       {
84215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84216       };
84217     }
84218   }
84219 }
84220
84221
84222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
84223   void * jresult ;
84224   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
84225
84226   {
84227     try {
84228       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
84229     } catch (std::out_of_range& e) {
84230       {
84231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84232       };
84233     } catch (std::exception& e) {
84234       {
84235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84236       };
84237     } catch (...) {
84238       {
84239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84240       };
84241     }
84242   }
84243   jresult = (void *)result;
84244   return jresult;
84245 }
84246
84247
84248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
84249   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84250
84251   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84252   {
84253     try {
84254       delete arg1;
84255     } catch (std::out_of_range& e) {
84256       {
84257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84258       };
84259     } catch (std::exception& e) {
84260       {
84261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84262       };
84263     } catch (...) {
84264       {
84265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84266       };
84267     }
84268   }
84269 }
84270
84271
84272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
84273   unsigned int jresult ;
84274   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84275   bool result;
84276
84277   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84278   {
84279     try {
84280       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);
84281     } catch (std::out_of_range& e) {
84282       {
84283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84284       };
84285     } catch (std::exception& e) {
84286       {
84287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84288       };
84289     } catch (...) {
84290       {
84291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84292       };
84293     }
84294   }
84295   jresult = result;
84296   return jresult;
84297 }
84298
84299
84300 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
84301   unsigned long jresult ;
84302   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84303   std::size_t result;
84304
84305   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84306   {
84307     try {
84308       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);
84309     } catch (std::out_of_range& e) {
84310       {
84311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84312       };
84313     } catch (std::exception& e) {
84314       {
84315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84316       };
84317     } catch (...) {
84318       {
84319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84320       };
84321     }
84322   }
84323   jresult = (unsigned long)result;
84324   return jresult;
84325 }
84326
84327
84328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
84329   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84330   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
84331
84332   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84333   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
84334   {
84335     try {
84336       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
84337     } catch (std::out_of_range& e) {
84338       {
84339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84340       };
84341     } catch (std::exception& e) {
84342       {
84343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84344       };
84345     } catch (...) {
84346       {
84347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84348       };
84349     }
84350   }
84351 }
84352
84353
84354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
84355   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84356   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
84357
84358   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84359   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
84360   {
84361     try {
84362       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
84363     } catch (std::out_of_range& e) {
84364       {
84365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84366       };
84367     } catch (std::exception& e) {
84368       {
84369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84370       };
84371     } catch (...) {
84372       {
84373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84374       };
84375     }
84376   }
84377 }
84378
84379
84380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
84381   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84382   Dali::Toolkit::ProgressBar arg2 ;
84383   float arg3 ;
84384   float arg4 ;
84385   Dali::Toolkit::ProgressBar *argp2 ;
84386
84387   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84388   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
84389   if (!argp2) {
84390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
84391     return ;
84392   }
84393   arg2 = *argp2;
84394   arg3 = (float)jarg3;
84395   arg4 = (float)jarg4;
84396   {
84397     try {
84398       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
84399     } catch (std::out_of_range& e) {
84400       {
84401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84402       };
84403     } catch (std::exception& e) {
84404       {
84405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84406       };
84407     } catch (...) {
84408       {
84409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84410       };
84411     }
84412   }
84413 }
84414
84415
84416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
84417   void * jresult ;
84418   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
84419
84420   {
84421     try {
84422       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
84423     } catch (std::out_of_range& e) {
84424       {
84425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84426       };
84427     } catch (std::exception& e) {
84428       {
84429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84430       };
84431     } catch (...) {
84432       {
84433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84434       };
84435     }
84436   }
84437   jresult = (void *)result;
84438   return jresult;
84439 }
84440
84441
84442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
84443   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84444
84445   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84446   {
84447     try {
84448       delete arg1;
84449     } catch (std::out_of_range& e) {
84450       {
84451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84452       };
84453     } catch (std::exception& e) {
84454       {
84455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84456       };
84457     } catch (...) {
84458       {
84459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84460       };
84461     }
84462   }
84463 }
84464
84465
84466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
84467   unsigned int jresult ;
84468   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84469   bool result;
84470
84471   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84472   {
84473     try {
84474       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);
84475     } catch (std::out_of_range& e) {
84476       {
84477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84478       };
84479     } catch (std::exception& e) {
84480       {
84481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84482       };
84483     } catch (...) {
84484       {
84485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84486       };
84487     }
84488   }
84489   jresult = result;
84490   return jresult;
84491 }
84492
84493
84494 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
84495   unsigned long jresult ;
84496   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84497   std::size_t result;
84498
84499   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84500   {
84501     try {
84502       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);
84503     } catch (std::out_of_range& e) {
84504       {
84505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84506       };
84507     } catch (std::exception& e) {
84508       {
84509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84510       };
84511     } catch (...) {
84512       {
84513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84514       };
84515     }
84516   }
84517   jresult = (unsigned long)result;
84518   return jresult;
84519 }
84520
84521
84522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
84523   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84524   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
84525
84526   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84527   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
84528   {
84529     try {
84530       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
84531     } catch (std::out_of_range& e) {
84532       {
84533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84534       };
84535     } catch (std::exception& e) {
84536       {
84537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84538       };
84539     } catch (...) {
84540       {
84541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84542       };
84543     }
84544   }
84545 }
84546
84547
84548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
84549   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84550   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
84551
84552   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84553   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
84554   {
84555     try {
84556       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
84557     } catch (std::out_of_range& e) {
84558       {
84559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84560       };
84561     } catch (std::exception& e) {
84562       {
84563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84564       };
84565     } catch (...) {
84566       {
84567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84568       };
84569     }
84570   }
84571 }
84572
84573
84574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
84575   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84576   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
84577
84578   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84579   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
84580   if (!arg2) {
84581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
84582     return ;
84583   }
84584   {
84585     try {
84586       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
84587     } catch (std::out_of_range& e) {
84588       {
84589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84590       };
84591     } catch (std::exception& e) {
84592       {
84593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84594       };
84595     } catch (...) {
84596       {
84597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84598       };
84599     }
84600   }
84601 }
84602
84603
84604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
84605   void * jresult ;
84606   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
84607
84608   {
84609     try {
84610       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
84611     } catch (std::out_of_range& e) {
84612       {
84613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84614       };
84615     } catch (std::exception& e) {
84616       {
84617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84618       };
84619     } catch (...) {
84620       {
84621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84622       };
84623     }
84624   }
84625   jresult = (void *)result;
84626   return jresult;
84627 }
84628
84629
84630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
84631   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84632
84633   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84634   {
84635     try {
84636       delete arg1;
84637     } catch (std::out_of_range& e) {
84638       {
84639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84640       };
84641     } catch (std::exception& e) {
84642       {
84643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84644       };
84645     } catch (...) {
84646       {
84647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84648       };
84649     }
84650   }
84651 }
84652
84653
84654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
84655   unsigned int jresult ;
84656   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84657   bool result;
84658
84659   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84660   {
84661     try {
84662       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
84663     } catch (std::out_of_range& e) {
84664       {
84665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84666       };
84667     } catch (std::exception& e) {
84668       {
84669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84670       };
84671     } catch (...) {
84672       {
84673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84674       };
84675     }
84676   }
84677   jresult = result;
84678   return jresult;
84679 }
84680
84681
84682 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
84683   unsigned long jresult ;
84684   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84685   std::size_t result;
84686
84687   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84688   {
84689     try {
84690       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
84691     } catch (std::out_of_range& e) {
84692       {
84693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84694       };
84695     } catch (std::exception& e) {
84696       {
84697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84698       };
84699     } catch (...) {
84700       {
84701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84702       };
84703     }
84704   }
84705   jresult = (unsigned long)result;
84706   return jresult;
84707 }
84708
84709
84710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
84711   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84712   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
84713
84714   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84715   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
84716   {
84717     try {
84718       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
84719     } catch (std::out_of_range& e) {
84720       {
84721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84722       };
84723     } catch (std::exception& e) {
84724       {
84725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84726       };
84727     } catch (...) {
84728       {
84729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84730       };
84731     }
84732   }
84733 }
84734
84735
84736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
84737   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84738   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
84739
84740   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84741   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
84742   {
84743     try {
84744       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
84745     } catch (std::out_of_range& e) {
84746       {
84747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84748       };
84749     } catch (std::exception& e) {
84750       {
84751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84752       };
84753     } catch (...) {
84754       {
84755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84756       };
84757     }
84758   }
84759 }
84760
84761
84762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
84763   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84764   Dali::Vector2 *arg2 = 0 ;
84765
84766   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84767   arg2 = (Dali::Vector2 *)jarg2;
84768   if (!arg2) {
84769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84770     return ;
84771   }
84772   {
84773     try {
84774       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
84775     } catch (std::out_of_range& e) {
84776       {
84777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84778       };
84779     } catch (std::exception& e) {
84780       {
84781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84782       };
84783     } catch (...) {
84784       {
84785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84786       };
84787     }
84788   }
84789 }
84790
84791
84792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
84793   void * jresult ;
84794   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
84795
84796   {
84797     try {
84798       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
84799     } catch (std::out_of_range& e) {
84800       {
84801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84802       };
84803     } catch (std::exception& e) {
84804       {
84805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84806       };
84807     } catch (...) {
84808       {
84809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84810       };
84811     }
84812   }
84813   jresult = (void *)result;
84814   return jresult;
84815 }
84816
84817
84818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
84819   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84820
84821   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84822   {
84823     try {
84824       delete arg1;
84825     } catch (std::out_of_range& e) {
84826       {
84827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84828       };
84829     } catch (std::exception& e) {
84830       {
84831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84832       };
84833     } catch (...) {
84834       {
84835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84836       };
84837     }
84838   }
84839 }
84840
84841
84842
84843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
84844   unsigned int jresult ;
84845   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84846   bool result;
84847
84848   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84849   {
84850     try {
84851       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);
84852     } catch (std::out_of_range& e) {
84853       {
84854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84855       };
84856     } catch (std::exception& e) {
84857       {
84858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84859       };
84860     } catch (...) {
84861       {
84862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84863       };
84864     }
84865   }
84866   jresult = result;
84867   return jresult;
84868 }
84869
84870
84871 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
84872   unsigned long jresult ;
84873   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84874   std::size_t result;
84875
84876   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84877   {
84878     try {
84879       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);
84880     } catch (std::out_of_range& e) {
84881       {
84882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84883       };
84884     } catch (std::exception& e) {
84885       {
84886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84887       };
84888     } catch (...) {
84889       {
84890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84891       };
84892     }
84893   }
84894   jresult = (unsigned long)result;
84895   return jresult;
84896 }
84897
84898
84899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
84900   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84901   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
84902
84903   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84904   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
84905   {
84906     try {
84907       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
84908     } catch (std::out_of_range& e) {
84909       {
84910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84911       };
84912     } catch (std::exception& e) {
84913       {
84914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84915       };
84916     } catch (...) {
84917       {
84918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84919       };
84920     }
84921   }
84922 }
84923
84924
84925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
84926   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84927   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
84928
84929   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84930   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
84931   {
84932     try {
84933       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
84934     } catch (std::out_of_range& e) {
84935       {
84936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84937       };
84938     } catch (std::exception& e) {
84939       {
84940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84941       };
84942     } catch (...) {
84943       {
84944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84945       };
84946     }
84947   }
84948 }
84949
84950
84951 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
84952   unsigned int jresult ;
84953   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84954   Dali::Toolkit::Control arg2 ;
84955   Dali::KeyEvent *arg3 = 0 ;
84956   Dali::Toolkit::Control *argp2 ;
84957   bool result;
84958
84959   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84960   argp2 = (Dali::Toolkit::Control *)jarg2;
84961   if (!argp2) {
84962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
84963     return 0;
84964   }
84965   arg2 = *argp2;
84966   arg3 = (Dali::KeyEvent *)jarg3;
84967   if (!arg3) {
84968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
84969     return 0;
84970   }
84971   {
84972     try {
84973       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);
84974     } catch (std::out_of_range& e) {
84975       {
84976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84977       };
84978     } catch (std::exception& e) {
84979       {
84980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84981       };
84982     } catch (...) {
84983       {
84984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84985       };
84986     }
84987   }
84988   jresult = result;
84989   return jresult;
84990 }
84991
84992
84993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
84994   void * jresult ;
84995   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
84996
84997   {
84998     try {
84999       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
85000     } catch (std::out_of_range& e) {
85001       {
85002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85003       };
85004     } catch (std::exception& e) {
85005       {
85006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85007       };
85008     } catch (...) {
85009       {
85010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85011       };
85012     }
85013   }
85014   jresult = (void *)result;
85015   return jresult;
85016 }
85017
85018
85019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
85020   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
85021
85022   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
85023   {
85024     try {
85025       delete arg1;
85026     } catch (std::out_of_range& e) {
85027       {
85028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85029       };
85030     } catch (std::exception& e) {
85031       {
85032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85033       };
85034     } catch (...) {
85035       {
85036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85037       };
85038     }
85039   }
85040 }
85041
85042
85043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
85044   unsigned int jresult ;
85045   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85046   bool result;
85047
85048   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85049   {
85050     try {
85051       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
85052     } catch (std::out_of_range& e) {
85053       {
85054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85055       };
85056     } catch (std::exception& e) {
85057       {
85058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85059       };
85060     } catch (...) {
85061       {
85062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85063       };
85064     }
85065   }
85066   jresult = result;
85067   return jresult;
85068 }
85069
85070
85071 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
85072   unsigned long jresult ;
85073   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85074   std::size_t result;
85075
85076   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85077   {
85078     try {
85079       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
85080     } catch (std::out_of_range& e) {
85081       {
85082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85083       };
85084     } catch (std::exception& e) {
85085       {
85086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85087       };
85088     } catch (...) {
85089       {
85090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85091       };
85092     }
85093   }
85094   jresult = (unsigned long)result;
85095   return jresult;
85096 }
85097
85098
85099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
85100   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85101   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
85102
85103   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85104   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
85105   {
85106     try {
85107       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
85108     } catch (std::out_of_range& e) {
85109       {
85110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85111       };
85112     } catch (std::exception& e) {
85113       {
85114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85115       };
85116     } catch (...) {
85117       {
85118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85119       };
85120     }
85121   }
85122 }
85123
85124
85125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
85126   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85127   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
85128
85129   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85130   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
85131   {
85132     try {
85133       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
85134     } catch (std::out_of_range& e) {
85135       {
85136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85137       };
85138     } catch (std::exception& e) {
85139       {
85140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85141       };
85142     } catch (...) {
85143       {
85144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85145       };
85146     }
85147   }
85148 }
85149
85150
85151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
85152   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85153   Dali::Toolkit::Control arg2 ;
85154   Dali::Toolkit::Control *argp2 ;
85155
85156   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85157   argp2 = (Dali::Toolkit::Control *)jarg2;
85158   if (!argp2) {
85159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
85160     return ;
85161   }
85162   arg2 = *argp2;
85163   {
85164     try {
85165       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
85166     } catch (std::out_of_range& e) {
85167       {
85168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85169       };
85170     } catch (std::exception& e) {
85171       {
85172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85173       };
85174     } catch (...) {
85175       {
85176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85177       };
85178     }
85179   }
85180 }
85181
85182
85183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
85184   void * jresult ;
85185   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
85186
85187   {
85188     try {
85189       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
85190     } catch (std::out_of_range& e) {
85191       {
85192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85193       };
85194     } catch (std::exception& e) {
85195       {
85196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85197       };
85198     } catch (...) {
85199       {
85200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85201       };
85202     }
85203   }
85204   jresult = (void *)result;
85205   return jresult;
85206 }
85207
85208
85209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
85210   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85211
85212   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85213   {
85214     try {
85215       delete arg1;
85216     } catch (std::out_of_range& e) {
85217       {
85218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85219       };
85220     } catch (std::exception& e) {
85221       {
85222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85223       };
85224     } catch (...) {
85225       {
85226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85227       };
85228     }
85229   }
85230 }
85231
85232
85233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
85234   unsigned int jresult ;
85235   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85236   bool result;
85237
85238   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85239   {
85240     try {
85241       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
85242     } catch (std::out_of_range& e) {
85243       {
85244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85245       };
85246     } catch (std::exception& e) {
85247       {
85248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85249       };
85250     } catch (...) {
85251       {
85252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85253       };
85254     }
85255   }
85256   jresult = result;
85257   return jresult;
85258 }
85259
85260
85261 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
85262   unsigned long jresult ;
85263   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85264   std::size_t result;
85265
85266   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85267   {
85268     try {
85269       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
85270     } catch (std::out_of_range& e) {
85271       {
85272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85273       };
85274     } catch (std::exception& e) {
85275       {
85276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85277       };
85278     } catch (...) {
85279       {
85280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85281       };
85282     }
85283   }
85284   jresult = (unsigned long)result;
85285   return jresult;
85286 }
85287
85288
85289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
85290   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85291   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
85292
85293   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85294   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
85295   {
85296     try {
85297       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
85298     } catch (std::out_of_range& e) {
85299       {
85300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85301       };
85302     } catch (std::exception& e) {
85303       {
85304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85305       };
85306     } catch (...) {
85307       {
85308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85309       };
85310     }
85311   }
85312 }
85313
85314
85315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
85316   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85317   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
85318
85319   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85320   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
85321   {
85322     try {
85323       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
85324     } catch (std::out_of_range& e) {
85325       {
85326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85327       };
85328     } catch (std::exception& e) {
85329       {
85330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85331       };
85332     } catch (...) {
85333       {
85334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85335       };
85336     }
85337   }
85338 }
85339
85340
85341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
85342   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85343   Dali::Toolkit::VideoView *arg2 = 0 ;
85344
85345   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85346   arg2 = (Dali::Toolkit::VideoView *)jarg2;
85347   if (!arg2) {
85348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
85349     return ;
85350   }
85351   {
85352     try {
85353       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
85354     } catch (std::out_of_range& e) {
85355       {
85356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85357       };
85358     } catch (std::exception& e) {
85359       {
85360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85361       };
85362     } catch (...) {
85363       {
85364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85365       };
85366     }
85367   }
85368 }
85369
85370
85371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
85372   void * jresult ;
85373   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
85374
85375   {
85376     try {
85377       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
85378     } catch (std::out_of_range& e) {
85379       {
85380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85381       };
85382     } catch (std::exception& e) {
85383       {
85384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85385       };
85386     } catch (...) {
85387       {
85388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85389       };
85390     }
85391   }
85392   jresult = (void *)result;
85393   return jresult;
85394 }
85395
85396
85397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
85398   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85399
85400   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85401   {
85402     try {
85403       delete arg1;
85404     } catch (std::out_of_range& e) {
85405       {
85406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85407       };
85408     } catch (std::exception& e) {
85409       {
85410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85411       };
85412     } catch (...) {
85413       {
85414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85415       };
85416     }
85417   }
85418 }
85419
85420
85421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
85422   unsigned int jresult ;
85423   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85424   bool result;
85425
85426   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85427   {
85428     try {
85429       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
85430     } catch (std::out_of_range& e) {
85431       {
85432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85433       };
85434     } catch (std::exception& e) {
85435       {
85436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85437       };
85438     } catch (...) {
85439       {
85440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85441       };
85442     }
85443   }
85444   jresult = result;
85445   return jresult;
85446 }
85447
85448
85449 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
85450   unsigned long jresult ;
85451   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85452   std::size_t result;
85453
85454   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85455   {
85456     try {
85457       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
85458     } catch (std::out_of_range& e) {
85459       {
85460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85461       };
85462     } catch (std::exception& e) {
85463       {
85464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85465       };
85466     } catch (...) {
85467       {
85468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85469       };
85470     }
85471   }
85472   jresult = (unsigned long)result;
85473   return jresult;
85474 }
85475
85476
85477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
85478   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85479   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
85480
85481   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85482   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
85483   {
85484     try {
85485       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
85486     } catch (std::out_of_range& e) {
85487       {
85488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85489       };
85490     } catch (std::exception& e) {
85491       {
85492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85493       };
85494     } catch (...) {
85495       {
85496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85497       };
85498     }
85499   }
85500 }
85501
85502
85503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
85504   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85505   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
85506
85507   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85508   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
85509   {
85510     try {
85511       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
85512     } catch (std::out_of_range& e) {
85513       {
85514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85515       };
85516     } catch (std::exception& e) {
85517       {
85518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85519       };
85520     } catch (...) {
85521       {
85522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85523       };
85524     }
85525   }
85526 }
85527
85528
85529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
85530   unsigned int jresult ;
85531   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85532   Dali::Toolkit::Slider arg2 ;
85533   float arg3 ;
85534   Dali::Toolkit::Slider *argp2 ;
85535   bool result;
85536
85537   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85538   argp2 = (Dali::Toolkit::Slider *)jarg2;
85539   if (!argp2) {
85540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
85541     return 0;
85542   }
85543   arg2 = *argp2;
85544   arg3 = (float)jarg3;
85545   {
85546     try {
85547       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
85548     } catch (std::out_of_range& e) {
85549       {
85550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85551       };
85552     } catch (std::exception& e) {
85553       {
85554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85555       };
85556     } catch (...) {
85557       {
85558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85559       };
85560     }
85561   }
85562   jresult = result;
85563   return jresult;
85564 }
85565
85566
85567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
85568   void * jresult ;
85569   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
85570
85571   {
85572     try {
85573       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
85574     } catch (std::out_of_range& e) {
85575       {
85576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85577       };
85578     } catch (std::exception& e) {
85579       {
85580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85581       };
85582     } catch (...) {
85583       {
85584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85585       };
85586     }
85587   }
85588   jresult = (void *)result;
85589   return jresult;
85590 }
85591
85592
85593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
85594   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85595
85596   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85597   {
85598     try {
85599       delete arg1;
85600     } catch (std::out_of_range& e) {
85601       {
85602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85603       };
85604     } catch (std::exception& e) {
85605       {
85606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85607       };
85608     } catch (...) {
85609       {
85610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85611       };
85612     }
85613   }
85614 }
85615
85616
85617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
85618   unsigned int jresult ;
85619   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85620   bool result;
85621
85622   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85623   {
85624     try {
85625       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
85626     } catch (std::out_of_range& e) {
85627       {
85628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85629       };
85630     } catch (std::exception& e) {
85631       {
85632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85633       };
85634     } catch (...) {
85635       {
85636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85637       };
85638     }
85639   }
85640   jresult = result;
85641   return jresult;
85642 }
85643
85644
85645 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
85646   unsigned long jresult ;
85647   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85648   std::size_t result;
85649
85650   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85651   {
85652     try {
85653       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
85654     } catch (std::out_of_range& e) {
85655       {
85656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85657       };
85658     } catch (std::exception& e) {
85659       {
85660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85661       };
85662     } catch (...) {
85663       {
85664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85665       };
85666     }
85667   }
85668   jresult = (unsigned long)result;
85669   return jresult;
85670 }
85671
85672
85673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
85674   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85675   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
85676
85677   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85678   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
85679   {
85680     try {
85681       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
85682     } catch (std::out_of_range& e) {
85683       {
85684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85685       };
85686     } catch (std::exception& e) {
85687       {
85688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85689       };
85690     } catch (...) {
85691       {
85692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85693       };
85694     }
85695   }
85696 }
85697
85698
85699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
85700   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85701   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
85702
85703   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85704   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
85705   {
85706     try {
85707       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
85708     } catch (std::out_of_range& e) {
85709       {
85710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85711       };
85712     } catch (std::exception& e) {
85713       {
85714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85715       };
85716     } catch (...) {
85717       {
85718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85719       };
85720     }
85721   }
85722 }
85723
85724
85725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
85726   unsigned int jresult ;
85727   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85728   Dali::Toolkit::Slider arg2 ;
85729   int arg3 ;
85730   Dali::Toolkit::Slider *argp2 ;
85731   bool result;
85732
85733   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85734   argp2 = (Dali::Toolkit::Slider *)jarg2;
85735   if (!argp2) {
85736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
85737     return 0;
85738   }
85739   arg2 = *argp2;
85740   arg3 = (int)jarg3;
85741   {
85742     try {
85743       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
85744     } catch (std::out_of_range& e) {
85745       {
85746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85747       };
85748     } catch (std::exception& e) {
85749       {
85750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85751       };
85752     } catch (...) {
85753       {
85754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85755       };
85756     }
85757   }
85758   jresult = result;
85759   return jresult;
85760 }
85761
85762
85763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
85764   void * jresult ;
85765   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
85766
85767   {
85768     try {
85769       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
85770     } catch (std::out_of_range& e) {
85771       {
85772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85773       };
85774     } catch (std::exception& e) {
85775       {
85776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85777       };
85778     } catch (...) {
85779       {
85780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85781       };
85782     }
85783   }
85784   jresult = (void *)result;
85785   return jresult;
85786 }
85787
85788
85789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
85790   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85791
85792   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85793   {
85794     try {
85795       delete arg1;
85796     } catch (std::out_of_range& e) {
85797       {
85798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85799       };
85800     } catch (std::exception& e) {
85801       {
85802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85803       };
85804     } catch (...) {
85805       {
85806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85807       };
85808     }
85809   }
85810 }
85811
85812
85813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
85814   void * jresult ;
85815   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
85816
85817   {
85818     try {
85819       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
85820     } catch (std::out_of_range& e) {
85821       {
85822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85823       };
85824     } catch (std::exception& e) {
85825       {
85826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85827       };
85828     } catch (...) {
85829       {
85830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85831       };
85832     }
85833   }
85834   jresult = (void *)result;
85835   return jresult;
85836 }
85837
85838
85839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
85840   void * jresult ;
85841   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
85842   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
85843
85844   arg1 = (Dali::Toolkit::Ruler *)jarg1;
85845   {
85846     try {
85847       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
85848     } catch (std::out_of_range& e) {
85849       {
85850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85851       };
85852     } catch (std::exception& e) {
85853       {
85854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85855       };
85856     } catch (...) {
85857       {
85858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85859       };
85860     }
85861   }
85862   jresult = (void *)result;
85863   return jresult;
85864 }
85865
85866
85867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
85868   void * jresult ;
85869   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
85870   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
85871
85872   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85873   if (!arg1) {
85874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
85875     return 0;
85876   }
85877   {
85878     try {
85879       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
85880     } catch (std::out_of_range& e) {
85881       {
85882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85883       };
85884     } catch (std::exception& e) {
85885       {
85886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85887       };
85888     } catch (...) {
85889       {
85890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85891       };
85892     }
85893   }
85894   jresult = (void *)result;
85895   return jresult;
85896 }
85897
85898
85899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
85900   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85901
85902   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85903   {
85904     try {
85905       delete arg1;
85906     } catch (std::out_of_range& e) {
85907       {
85908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85909       };
85910     } catch (std::exception& e) {
85911       {
85912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85913       };
85914     } catch (...) {
85915       {
85916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85917       };
85918     }
85919   }
85920 }
85921
85922
85923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
85924   void * jresult ;
85925   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85926   Dali::Toolkit::Ruler *result = 0 ;
85927
85928   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85929   {
85930     try {
85931       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
85932     } catch (std::out_of_range& e) {
85933       {
85934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85935       };
85936     } catch (std::exception& e) {
85937       {
85938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85939       };
85940     } catch (...) {
85941       {
85942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85943       };
85944     }
85945   }
85946   jresult = (void *)result;
85947   return jresult;
85948 }
85949
85950
85951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
85952   void * jresult ;
85953   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85954   Dali::Toolkit::Ruler *result = 0 ;
85955
85956   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85957   {
85958     try {
85959       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
85960     } catch (std::out_of_range& e) {
85961       {
85962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85963       };
85964     } catch (std::exception& e) {
85965       {
85966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85967       };
85968     } catch (...) {
85969       {
85970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85971       };
85972     }
85973   }
85974   jresult = (void *)result;
85975   return jresult;
85976 }
85977
85978
85979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
85980   void * jresult ;
85981   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85982   Dali::Toolkit::Ruler *result = 0 ;
85983
85984   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85985   {
85986     try {
85987       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
85988     } catch (std::out_of_range& e) {
85989       {
85990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85991       };
85992     } catch (std::exception& e) {
85993       {
85994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85995       };
85996     } catch (...) {
85997       {
85998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85999       };
86000     }
86001   }
86002   jresult = (void *)result;
86003   return jresult;
86004 }
86005
86006
86007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
86008   void * jresult ;
86009   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86010   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
86011   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
86012
86013   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86014   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
86015   if (!arg2) {
86016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
86017     return 0;
86018   }
86019   {
86020     try {
86021       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
86022     } catch (std::out_of_range& e) {
86023       {
86024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86025       };
86026     } catch (std::exception& e) {
86027       {
86028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86029       };
86030     } catch (...) {
86031       {
86032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86033       };
86034     }
86035   }
86036   jresult = (void *)result;
86037   return jresult;
86038 }
86039
86040
86041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
86042   void * jresult ;
86043   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86044   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
86045   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
86046
86047   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86048   arg2 = (Dali::Toolkit::Ruler *)jarg2;
86049   {
86050     try {
86051       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
86052     } catch (std::out_of_range& e) {
86053       {
86054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86055       };
86056     } catch (std::exception& e) {
86057       {
86058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86059       };
86060     } catch (...) {
86061       {
86062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86063       };
86064     }
86065   }
86066   jresult = (void *)result;
86067   return jresult;
86068 }
86069
86070
86071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
86072   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86073
86074   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86075   {
86076     try {
86077       (arg1)->Reset();
86078     } catch (std::out_of_range& e) {
86079       {
86080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86081       };
86082     } catch (std::exception& e) {
86083       {
86084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86085       };
86086     } catch (...) {
86087       {
86088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86089       };
86090     }
86091   }
86092 }
86093
86094
86095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
86096   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86097   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
86098
86099   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86100   arg2 = (Dali::Toolkit::Ruler *)jarg2;
86101   {
86102     try {
86103       (arg1)->Reset(arg2);
86104     } catch (std::out_of_range& e) {
86105       {
86106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86107       };
86108     } catch (std::exception& e) {
86109       {
86110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86111       };
86112     } catch (...) {
86113       {
86114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86115       };
86116     }
86117   }
86118 }
86119
86120
86121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
86122   void * jresult ;
86123   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86124   Dali::Toolkit::Ruler *result = 0 ;
86125
86126   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86127   {
86128     try {
86129       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
86130     } catch (std::out_of_range& e) {
86131       {
86132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86133       };
86134     } catch (std::exception& e) {
86135       {
86136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86137       };
86138     } catch (...) {
86139       {
86140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86141       };
86142     }
86143   }
86144   jresult = (void *)result;
86145   return jresult;
86146 }
86147
86148
86149 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
86150   float jresult ;
86151   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86152   float arg2 ;
86153   float arg3 ;
86154   float result;
86155
86156   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86157   arg2 = (float)jarg2;
86158   arg3 = (float)jarg3;
86159   {
86160     try {
86161       result = (float)(*arg1)->Snap(arg2,arg3);
86162     } catch (std::out_of_range& e) {
86163       {
86164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86165       };
86166     } catch (std::exception& e) {
86167       {
86168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86169       };
86170     } catch (...) {
86171       {
86172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86173       };
86174     }
86175   }
86176   jresult = result;
86177   return jresult;
86178 }
86179
86180
86181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
86182   float jresult ;
86183   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86184   float arg2 ;
86185   float result;
86186
86187   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86188   arg2 = (float)jarg2;
86189   {
86190     try {
86191       result = (float)(*arg1)->Snap(arg2);
86192     } catch (std::out_of_range& e) {
86193       {
86194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86195       };
86196     } catch (std::exception& e) {
86197       {
86198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86199       };
86200     } catch (...) {
86201       {
86202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86203       };
86204     }
86205   }
86206   jresult = result;
86207   return jresult;
86208 }
86209
86210
86211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
86212   float jresult ;
86213   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86214   unsigned int arg2 ;
86215   unsigned int *arg3 = 0 ;
86216   bool arg4 ;
86217   float result;
86218
86219   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86220   arg2 = (unsigned int)jarg2;
86221   arg3 = (unsigned int *)jarg3;
86222   arg4 = jarg4 ? true : false;
86223   {
86224     try {
86225       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
86226     } catch (std::out_of_range& e) {
86227       {
86228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86229       };
86230     } catch (std::exception& e) {
86231       {
86232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86233       };
86234     } catch (...) {
86235       {
86236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86237       };
86238     }
86239   }
86240   jresult = result;
86241   return jresult;
86242 }
86243
86244
86245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
86246   unsigned int jresult ;
86247   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86248   float arg2 ;
86249   bool arg3 ;
86250   unsigned int result;
86251
86252   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86253   arg2 = (float)jarg2;
86254   arg3 = jarg3 ? true : false;
86255   {
86256     try {
86257       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
86258     } catch (std::out_of_range& e) {
86259       {
86260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86261       };
86262     } catch (std::exception& e) {
86263       {
86264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86265       };
86266     } catch (...) {
86267       {
86268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86269       };
86270     }
86271   }
86272   jresult = result;
86273   return jresult;
86274 }
86275
86276
86277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
86278   unsigned int jresult ;
86279   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86280   unsigned int result;
86281
86282   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86283   {
86284     try {
86285       result = (unsigned int)(*arg1)->GetTotalPages();
86286     } catch (std::out_of_range& e) {
86287       {
86288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86289       };
86290     } catch (std::exception& e) {
86291       {
86292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86293       };
86294     } catch (...) {
86295       {
86296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86297       };
86298     }
86299   }
86300   jresult = result;
86301   return jresult;
86302 }
86303
86304
86305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
86306   int jresult ;
86307   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86308   Dali::Toolkit::Ruler::RulerType result;
86309
86310   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86311   {
86312     try {
86313       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
86314     } catch (std::out_of_range& e) {
86315       {
86316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86317       };
86318     } catch (std::exception& e) {
86319       {
86320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86321       };
86322     } catch (...) {
86323       {
86324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86325       };
86326     }
86327   }
86328   jresult = (int)result;
86329   return jresult;
86330 }
86331
86332
86333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
86334   unsigned int jresult ;
86335   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86336   bool result;
86337
86338   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86339   {
86340     try {
86341       result = (bool)(*arg1)->IsEnabled();
86342     } catch (std::out_of_range& e) {
86343       {
86344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86345       };
86346     } catch (std::exception& e) {
86347       {
86348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86349       };
86350     } catch (...) {
86351       {
86352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86353       };
86354     }
86355   }
86356   jresult = result;
86357   return jresult;
86358 }
86359
86360
86361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
86362   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86363
86364   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86365   {
86366     try {
86367       (*arg1)->Enable();
86368     } catch (std::out_of_range& e) {
86369       {
86370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86371       };
86372     } catch (std::exception& e) {
86373       {
86374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86375       };
86376     } catch (...) {
86377       {
86378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86379       };
86380     }
86381   }
86382 }
86383
86384
86385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
86386   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86387
86388   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86389   {
86390     try {
86391       (*arg1)->Disable();
86392     } catch (std::out_of_range& e) {
86393       {
86394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86395       };
86396     } catch (std::exception& e) {
86397       {
86398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86399       };
86400     } catch (...) {
86401       {
86402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86403       };
86404     }
86405   }
86406 }
86407
86408
86409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
86410   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86411   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
86412   Dali::Toolkit::RulerDomain *argp2 ;
86413
86414   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86415   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
86416   if (!argp2) {
86417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
86418     return ;
86419   }
86420   arg2 = *argp2;
86421   {
86422     try {
86423       (*arg1)->SetDomain(arg2);
86424     } catch (std::out_of_range& e) {
86425       {
86426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86427       };
86428     } catch (std::exception& e) {
86429       {
86430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86431       };
86432     } catch (...) {
86433       {
86434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86435       };
86436     }
86437   }
86438 }
86439
86440
86441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
86442   void * jresult ;
86443   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86444   Dali::Toolkit::RulerDomain *result = 0 ;
86445
86446   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86447   {
86448     try {
86449       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
86450     } catch (std::out_of_range& e) {
86451       {
86452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86453       };
86454     } catch (std::exception& e) {
86455       {
86456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86457       };
86458     } catch (...) {
86459       {
86460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86461       };
86462     }
86463   }
86464   jresult = (void *)result;
86465   return jresult;
86466 }
86467
86468
86469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
86470   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86471
86472   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86473   {
86474     try {
86475       (*arg1)->DisableDomain();
86476     } catch (std::out_of_range& e) {
86477       {
86478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86479       };
86480     } catch (std::exception& e) {
86481       {
86482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86483       };
86484     } catch (...) {
86485       {
86486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86487       };
86488     }
86489   }
86490 }
86491
86492
86493 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
86494   float jresult ;
86495   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86496   float arg2 ;
86497   float arg3 ;
86498   float arg4 ;
86499   float result;
86500
86501   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86502   arg2 = (float)jarg2;
86503   arg3 = (float)jarg3;
86504   arg4 = (float)jarg4;
86505   {
86506     try {
86507       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
86508     } catch (std::out_of_range& e) {
86509       {
86510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86511       };
86512     } catch (std::exception& e) {
86513       {
86514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86515       };
86516     } catch (...) {
86517       {
86518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86519       };
86520     }
86521   }
86522   jresult = result;
86523   return jresult;
86524 }
86525
86526
86527 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
86528   float jresult ;
86529   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86530   float arg2 ;
86531   float arg3 ;
86532   float result;
86533
86534   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86535   arg2 = (float)jarg2;
86536   arg3 = (float)jarg3;
86537   {
86538     try {
86539       result = (float)(*arg1)->Clamp(arg2,arg3);
86540     } catch (std::out_of_range& e) {
86541       {
86542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86543       };
86544     } catch (std::exception& e) {
86545       {
86546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86547       };
86548     } catch (...) {
86549       {
86550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86551       };
86552     }
86553   }
86554   jresult = result;
86555   return jresult;
86556 }
86557
86558
86559 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
86560   float jresult ;
86561   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86562   float arg2 ;
86563   float result;
86564
86565   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86566   arg2 = (float)jarg2;
86567   {
86568     try {
86569       result = (float)(*arg1)->Clamp(arg2);
86570     } catch (std::out_of_range& e) {
86571       {
86572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86573       };
86574     } catch (std::exception& e) {
86575       {
86576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86577       };
86578     } catch (...) {
86579       {
86580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86581       };
86582     }
86583   }
86584   jresult = result;
86585   return jresult;
86586 }
86587
86588
86589 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
86590   float jresult ;
86591   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86592   float arg2 ;
86593   float arg3 ;
86594   float arg4 ;
86595   Dali::Toolkit::ClampState *arg5 = 0 ;
86596   float result;
86597
86598   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86599   arg2 = (float)jarg2;
86600   arg3 = (float)jarg3;
86601   arg4 = (float)jarg4;
86602   arg5 = (Dali::Toolkit::ClampState *)jarg5;
86603   if (!arg5) {
86604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
86605     return 0;
86606   }
86607   {
86608     try {
86609       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
86610     } catch (std::out_of_range& e) {
86611       {
86612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86613       };
86614     } catch (std::exception& e) {
86615       {
86616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86617       };
86618     } catch (...) {
86619       {
86620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86621       };
86622     }
86623   }
86624   jresult = result;
86625   return jresult;
86626 }
86627
86628
86629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
86630   float jresult ;
86631   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86632   float arg2 ;
86633   float arg3 ;
86634   float arg4 ;
86635   float arg5 ;
86636   float result;
86637
86638   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86639   arg2 = (float)jarg2;
86640   arg3 = (float)jarg3;
86641   arg4 = (float)jarg4;
86642   arg5 = (float)jarg5;
86643   {
86644     try {
86645       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
86646     } catch (std::out_of_range& e) {
86647       {
86648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86649       };
86650     } catch (std::exception& e) {
86651       {
86652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86653       };
86654     } catch (...) {
86655       {
86656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86657       };
86658     }
86659   }
86660   jresult = result;
86661   return jresult;
86662 }
86663
86664
86665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
86666   float jresult ;
86667   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86668   float arg2 ;
86669   float arg3 ;
86670   float arg4 ;
86671   float result;
86672
86673   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86674   arg2 = (float)jarg2;
86675   arg3 = (float)jarg3;
86676   arg4 = (float)jarg4;
86677   {
86678     try {
86679       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
86680     } catch (std::out_of_range& e) {
86681       {
86682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86683       };
86684     } catch (std::exception& e) {
86685       {
86686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86687       };
86688     } catch (...) {
86689       {
86690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86691       };
86692     }
86693   }
86694   jresult = result;
86695   return jresult;
86696 }
86697
86698
86699 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
86700   float jresult ;
86701   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86702   float arg2 ;
86703   float arg3 ;
86704   float result;
86705
86706   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86707   arg2 = (float)jarg2;
86708   arg3 = (float)jarg3;
86709   {
86710     try {
86711       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
86712     } catch (std::out_of_range& e) {
86713       {
86714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86715       };
86716     } catch (std::exception& e) {
86717       {
86718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86719       };
86720     } catch (...) {
86721       {
86722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86723       };
86724     }
86725   }
86726   jresult = result;
86727   return jresult;
86728 }
86729
86730
86731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
86732   float jresult ;
86733   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86734   float arg2 ;
86735   float result;
86736
86737   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86738   arg2 = (float)jarg2;
86739   {
86740     try {
86741       result = (float)(*arg1)->SnapAndClamp(arg2);
86742     } catch (std::out_of_range& e) {
86743       {
86744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86745       };
86746     } catch (std::exception& e) {
86747       {
86748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86749       };
86750     } catch (...) {
86751       {
86752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86753       };
86754     }
86755   }
86756   jresult = result;
86757   return jresult;
86758 }
86759
86760
86761 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
86762   float jresult ;
86763   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86764   float arg2 ;
86765   float arg3 ;
86766   float arg4 ;
86767   float arg5 ;
86768   Dali::Toolkit::ClampState *arg6 = 0 ;
86769   float result;
86770
86771   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86772   arg2 = (float)jarg2;
86773   arg3 = (float)jarg3;
86774   arg4 = (float)jarg4;
86775   arg5 = (float)jarg5;
86776   arg6 = (Dali::Toolkit::ClampState *)jarg6;
86777   if (!arg6) {
86778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
86779     return 0;
86780   }
86781   {
86782     try {
86783       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
86784     } catch (std::out_of_range& e) {
86785       {
86786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86787       };
86788     } catch (std::exception& e) {
86789       {
86790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86791       };
86792     } catch (...) {
86793       {
86794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86795       };
86796     }
86797   }
86798   jresult = result;
86799   return jresult;
86800 }
86801
86802
86803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
86804   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86805
86806   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86807   {
86808     try {
86809       (*arg1)->Reference();
86810     } catch (std::out_of_range& e) {
86811       {
86812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86813       };
86814     } catch (std::exception& e) {
86815       {
86816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86817       };
86818     } catch (...) {
86819       {
86820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86821       };
86822     }
86823   }
86824 }
86825
86826
86827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
86828   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86829
86830   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86831   {
86832     try {
86833       (*arg1)->Unreference();
86834     } catch (std::out_of_range& e) {
86835       {
86836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86837       };
86838     } catch (std::exception& e) {
86839       {
86840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86841       };
86842     } catch (...) {
86843       {
86844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86845       };
86846     }
86847   }
86848 }
86849
86850
86851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
86852   int jresult ;
86853   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86854   int result;
86855
86856   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86857   {
86858     try {
86859       result = (int)(*arg1)->ReferenceCount();
86860     } catch (std::out_of_range& e) {
86861       {
86862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86863       };
86864     } catch (std::exception& e) {
86865       {
86866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86867       };
86868     } catch (...) {
86869       {
86870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86871       };
86872     }
86873   }
86874   jresult = result;
86875   return jresult;
86876 }
86877
86878
86879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
86880   unsigned int jresult ;
86881   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86882   bool result;
86883
86884   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86885   {
86886     try {
86887       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
86888     } catch (std::out_of_range& e) {
86889       {
86890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86891       };
86892     } catch (std::exception& e) {
86893       {
86894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86895       };
86896     } catch (...) {
86897       {
86898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86899       };
86900     }
86901   }
86902   jresult = result;
86903   return jresult;
86904 }
86905
86906
86907 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
86908   unsigned long jresult ;
86909   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86910   std::size_t result;
86911
86912   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86913   {
86914     try {
86915       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
86916     } catch (std::out_of_range& e) {
86917       {
86918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86919       };
86920     } catch (std::exception& e) {
86921       {
86922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86923       };
86924     } catch (...) {
86925       {
86926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86927       };
86928     }
86929   }
86930   jresult = (unsigned long)result;
86931   return jresult;
86932 }
86933
86934
86935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
86936   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86937   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
86938
86939   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86940   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
86941   {
86942     try {
86943       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
86944     } catch (std::out_of_range& e) {
86945       {
86946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86947       };
86948     } catch (std::exception& e) {
86949       {
86950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86951       };
86952     } catch (...) {
86953       {
86954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86955       };
86956     }
86957   }
86958 }
86959
86960
86961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
86962   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86963   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
86964
86965   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86966   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
86967   {
86968     try {
86969       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
86970     } catch (std::out_of_range& e) {
86971       {
86972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86973       };
86974     } catch (std::exception& e) {
86975       {
86976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86977       };
86978     } catch (...) {
86979       {
86980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86981       };
86982     }
86983   }
86984 }
86985
86986
86987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
86988   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86989   Dali::Toolkit::Control arg2 ;
86990   Dali::Toolkit::Control *argp2 ;
86991
86992   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86993   argp2 = (Dali::Toolkit::Control *)jarg2;
86994   if (!argp2) {
86995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86996     return ;
86997   }
86998   arg2 = *argp2;
86999   {
87000     try {
87001       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
87002     } catch (std::out_of_range& e) {
87003       {
87004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87005       };
87006     } catch (std::exception& e) {
87007       {
87008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87009       };
87010     } catch (...) {
87011       {
87012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87013       };
87014     }
87015   }
87016 }
87017
87018
87019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
87020   void * jresult ;
87021   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
87022
87023   {
87024     try {
87025       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
87026     } catch (std::out_of_range& e) {
87027       {
87028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87029       };
87030     } catch (std::exception& e) {
87031       {
87032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87033       };
87034     } catch (...) {
87035       {
87036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87037       };
87038     }
87039   }
87040   jresult = (void *)result;
87041   return jresult;
87042 }
87043
87044
87045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
87046   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87047
87048   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87049   {
87050     try {
87051       delete arg1;
87052     } catch (std::out_of_range& e) {
87053       {
87054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87055       };
87056     } catch (std::exception& e) {
87057       {
87058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87059       };
87060     } catch (...) {
87061       {
87062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87063       };
87064     }
87065   }
87066 }
87067
87068 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
87069   Dali::RefObject *result = NULL;
87070
87071   if (arg1)
87072   {
87073     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
87074   }
87075   return result;
87076 }
87077
87078 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
87079     return (Dali::RefObject *)jarg1;
87080 }
87081
87082 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
87083     return (Dali::SignalObserver *)jarg1;
87084 }
87085
87086 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
87087     return (Dali::ConnectionTrackerInterface *)jarg1;
87088 }
87089
87090 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
87091     return (Dali::BaseHandle *)jarg1;
87092 }
87093
87094 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
87095     return (Dali::BaseHandle *)jarg1;
87096 }
87097
87098 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
87099     return (Dali::BaseHandle *)jarg1;
87100 }
87101
87102 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
87103     return (Dali::BaseHandle *)jarg1;
87104 }
87105
87106 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
87107     return (Dali::BaseHandle *)jarg1;
87108 }
87109
87110 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
87111     return (Dali::BaseHandle *)jarg1;
87112 }
87113
87114 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
87115     return (Dali::BaseHandle *)jarg1;
87116 }
87117
87118 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
87119     return (Dali::BaseHandle *)jarg1;
87120 }
87121
87122 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
87123     return (Dali::BaseHandle *)jarg1;
87124 }
87125
87126 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
87127     return (Dali::BaseHandle *)jarg1;
87128 }
87129
87130 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
87131     return (Dali::BaseHandle *)jarg1;
87132 }
87133
87134 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
87135     return (Dali::BaseHandle *)jarg1;
87136 }
87137
87138 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
87139     return (Dali::BaseHandle *)jarg1;
87140 }
87141
87142 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
87143     return (Dali::Handle *)jarg1;
87144 }
87145
87146 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
87147     return (Dali::Handle *)jarg1;
87148 }
87149
87150 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
87151     return (Dali::BaseHandle *)jarg1;
87152 }
87153
87154 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
87155     return (Dali::BaseHandle *)jarg1;
87156 }
87157
87158 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
87159     return (Dali::Handle *)jarg1;
87160 }
87161
87162 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
87163     return (Dali::BaseHandle *)jarg1;
87164 }
87165
87166 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
87167     return (Dali::Handle *)jarg1;
87168 }
87169
87170 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
87171     return (Dali::GestureDetector *)jarg1;
87172 }
87173
87174 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
87175     return (Dali::Gesture *)jarg1;
87176 }
87177
87178 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
87179     return (Dali::Handle *)jarg1;
87180 }
87181
87182 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
87183     return (Dali::Actor *)jarg1;
87184 }
87185
87186 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
87187     return (Dali::BaseHandle *)jarg1;
87188 }
87189
87190 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
87191     return (Dali::RefObject *)jarg1;
87192 }
87193
87194 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
87195     return (Dali::Actor *)jarg1;
87196 }
87197
87198 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
87199     return (Dali::GestureDetector *)jarg1;
87200 }
87201
87202 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
87203     return (Dali::Gesture *)jarg1;
87204 }
87205
87206 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
87207     return (Dali::GestureDetector *)jarg1;
87208 }
87209
87210 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
87211     return (Dali::Gesture *)jarg1;
87212 }
87213
87214 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
87215     return (Dali::GestureDetector *)jarg1;
87216 }
87217
87218 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
87219     return (Dali::Gesture *)jarg1;
87220 }
87221
87222 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
87223     return (Dali::BaseHandle *)jarg1;
87224 }
87225
87226 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
87227     return (Dali::Handle *)jarg1;
87228 }
87229
87230 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
87231     return (Dali::Handle *)jarg1;
87232 }
87233
87234 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
87235     return (Dali::Handle *)jarg1;
87236 }
87237
87238 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
87239     return (Dali::Image *)jarg1;
87240 }
87241
87242 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
87243     return (Dali::Image *)jarg1;
87244 }
87245
87246 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
87247     return (Dali::Image *)jarg1;
87248 }
87249
87250 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
87251     return (Dali::RefObject *)jarg1;
87252 }
87253
87254 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
87255     return (Dali::Image *)jarg1;
87256 }
87257
87258 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
87259     return (Dali::Image *)jarg1;
87260 }
87261
87262 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
87263     return (Dali::ResourceImage *)jarg1;
87264 }
87265
87266 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
87267     return (Dali::Actor *)jarg1;
87268 }
87269
87270 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
87271     return (Dali::BaseHandle *)jarg1;
87272 }
87273
87274 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
87275     return (Dali::BaseHandle *)jarg1;
87276 }
87277
87278
87279 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
87280     return (Dali::BaseHandle *)jarg1;
87281 }
87282
87283 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
87284     return (Dali::BaseHandle *)jarg1;
87285 }
87286
87287 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
87288     return (Dali::CustomActorImpl *)jarg1;
87289 }
87290
87291 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
87292     return (Dali::CustomActor *)jarg1;
87293 }
87294
87295 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
87296     return (Dali::BaseHandle *)jarg1;
87297 }
87298
87299 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
87300     return (Dali::Toolkit::Control *)jarg1;
87301 }
87302
87303 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
87304     return (Dali::Toolkit::Control *)jarg1;
87305 }
87306
87307 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
87308     return (Dali::Toolkit::Button *)jarg1;
87309 }
87310
87311 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
87312     return (Dali::Toolkit::Button *)jarg1;
87313 }
87314
87315 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
87316     return (Dali::Toolkit::Button *)jarg1;
87317 }
87318
87319 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
87320     return (Dali::Toolkit::Control *)jarg1;
87321 }
87322
87323 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
87324     return (Dali::Toolkit::Control *)jarg1;
87325 }
87326
87327 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
87328     return (Dali::Toolkit::Control *)jarg1;
87329 }
87330
87331 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
87332     return (Dali::Toolkit::Control *)jarg1;
87333 }
87334
87335 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
87336     return (Dali::Toolkit::Control *)jarg1;
87337 }
87338
87339 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
87340     return (Dali::RefObject *)jarg1;
87341 }
87342
87343 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
87344     return (Dali::Toolkit::Scrollable *)jarg1;
87345 }
87346
87347 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
87348     return (Dali::BaseHandle *)jarg1;
87349 }
87350
87351 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
87352     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
87353 }
87354
87355 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
87356     return (Dali::RefObject *)jarg1;
87357 }
87358
87359 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
87360     return (Dali::Toolkit::Ruler *)jarg1;
87361 }
87362
87363 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
87364     return (Dali::Toolkit::Ruler *)jarg1;
87365 }
87366
87367 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
87368     return (Dali::Toolkit::Scrollable *)jarg1;
87369 }
87370
87371 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
87372     return (Dali::Toolkit::Control *)jarg1;
87373 }
87374
87375
87376 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
87377     return (Dali::Toolkit::Control *)jarg1;
87378 }
87379
87380 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
87381     return (Dali::BaseHandle *)jarg1;
87382 }
87383
87384 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
87385     return (Dali::BaseHandle *)jarg1;
87386 }
87387
87388 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
87389     return (Dali::Toolkit::Control *)jarg1;
87390 }
87391
87392 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
87393     return (Dali::Toolkit::Control *)jarg1;
87394 }
87395
87396 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
87397     return (Dali::Toolkit::Control *)jarg1;
87398 }
87399
87400 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
87401     return (Dali::Toolkit::Control *)jarg1;
87402 }
87403
87404 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
87405     return (Dali::Toolkit::Control *)jarg1;
87406 }
87407
87408 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
87409     return (Dali::Toolkit::Control *)jarg1;
87410 }
87411
87412 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
87413     return (Dali::Toolkit::PageTurnView *)jarg1;
87414 }
87415
87416 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
87417     return (Dali::Toolkit::PageTurnView *)jarg1;
87418 }
87419
87420 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
87421     return (Dali::Toolkit::Button *)jarg1;
87422 }
87423
87424 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
87425     return (Dali::BaseHandle *)jarg1;
87426 }
87427
87428 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
87429     return (Dali::BaseHandle *)jarg1;
87430 }
87431
87432 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
87433     return (Dali::BaseHandle *)jarg1;
87434 }
87435
87436
87437 #ifdef __cplusplus
87438 }
87439 #endif